commit 6cd3bb5e65c2540719798e2d35e50050611ab42d
Author: igor <irigm@mail.ru>
Date:   Mon Nov 18 22:17:38 2024 +0500

    Первый

diff --git a/DBTools.java b/DBTools.java
new file mode 100644
index 0000000..c9800b3
--- /dev/null
+++ b/DBTools.java
@@ -0,0 +1,89 @@
+package tools;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.jdbc.core.RowMapper;
+import tctable.Tools;
+
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class DBTools {
+
+    public static class JsonRowMapper implements RowMapper<String> {
+
+        @Override
+        public String mapRow(ResultSet rs, int rowNum) throws SQLException {
+            ObjectMapper objectMapper = new ObjectMapper();
+            Map<String, Object> resultMap = new HashMap<>();
+
+            // Получаем метаданные ResultSet для получения названий столбцов
+            int columnCount = rs.getMetaData().getColumnCount();
+            for (int i = 1; i <= columnCount; i++) {
+                String columnName = rs.getMetaData().getColumnName(i);
+                Object columnValue = rs.getObject(i);
+                resultMap.put(columnName, columnValue);
+            }
+
+            // Преобразовываем Map в JSON строку
+            try {
+                return objectMapper.writeValueAsString(resultMap);
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to convert Map to JSON", e);
+            }
+        }
+
+    }
+
+    public static boolean hasColumn(ResultSet rs, String columnName) throws SQLException {
+        ResultSetMetaData metaData = rs.getMetaData();
+        int columnCount = metaData.getColumnCount();
+
+        for (int i = 1; i <= columnCount; i++) {
+            if (columnName.equalsIgnoreCase(metaData.getColumnName(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static String getSQLValue(String t, String v) {
+        //if($t=='object' && (strtoupper($v)!='NULL' && gettype($v)=='string')) $t='string'; //Если id шники uuid
+
+        if (t.equals("object") || t.equals("uid")) {
+            if (v.equals(""))
+                v = "NULL";
+        } else if (t.equals("i4") || t.equals("integer")) {
+            if (v.equals(""))
+                v = "NULL";
+        } else if (t.equals("f8")) {
+            if (v.equals(""))
+                v = "NULL";
+            v = Tools.replaceAll(v,",", "."); //The decimal part: point.
+        } else if (t.equals("f4")) {
+            if (v.equals(""))
+                v = "NULL";
+            v = Tools.replaceAll(v,",", "."); //The decimal part: point.
+        } else if (t.equals("b")) {
+            if (v.equals(""))
+                v = "NULL";
+            else if (v.equals("1"))
+                v = "true";
+            else if (v.equals("0"))
+                v = "false";
+        } else if (t.equals("string") || t.equals("text") || t.equals("dateTime") || t.equals("date")) {
+            if (v.equals("")) {
+                v = "NULL";
+            } else {
+                v = Tools.replaceAll(v,"'", "''");
+                v = "'" + v + "'";
+            }
+        } else {
+            v = "'" + v + "'";
+        }
+        return v;
+    }
+
+}
diff --git a/EmailUtility.java b/EmailUtility.java
new file mode 100644
index 0000000..7bf90db
--- /dev/null
+++ b/EmailUtility.java
@@ -0,0 +1,65 @@
+//From: http://www.codejava.net/java-ee/jsp/sending-e-mail-with-jsp-servlet-and-javamail
+package tools;
+
+import java.util.Date;
+import java.util.Properties;
+ 
+import javax.mail.Authenticator;
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.PasswordAuthentication;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.AddressException;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+ 
+/**
+ * A utility class for sending e-mail messages
+ * @author www.codejava.net
+ *
+ */
+public class EmailUtility {
+
+    public static void sendEmail(String host, String port,
+            final String userName, final String password, String toAddress,
+            String subject, String message) throws AddressException,
+            MessagingException
+    {
+		// sets SMTP server properties
+		Properties properties = new Properties();
+		
+		properties.put("mail.smtp.host", host);
+		properties.put("mail.smtp.port", port);
+		properties.put("mail.smtp.auth", "true");
+		//properties.put("mail.smtp.starttls.enable","true"); STARTTLS requested but already using SSL
+		properties.put("mail.smtp.EnableSSL.enable","true");
+		properties.put("mail.smtp.socketFactory.port", port);
+		properties.put("mail.smtp.socketFactory.class","javax.net.ssl.SSLSocketFactory");
+		//properties.put("mail.debug", "true"); 
+		 
+
+		// creates a new session with an authenticator
+		Authenticator auth = new Authenticator() {
+			public PasswordAuthentication getPasswordAuthentication() {
+				return new PasswordAuthentication(userName, password);
+			}
+		};
+ 
+		Session session = Session.getInstance(properties, auth);
+ 
+		//creates a new e-mail message
+		Message msg = new MimeMessage(session);
+ 
+		msg.setFrom(new InternetAddress(userName));
+		InternetAddress[] toAddresses = { new InternetAddress(toAddress) };
+		msg.setRecipients(Message.RecipientType.TO, toAddresses);
+		msg.setSubject(subject);
+		msg.setSentDate(new Date());
+		//msg.setText(message);
+		msg.setContent(message, "text/html; charset=utf-8");
+ 
+		// sends the e-mail
+		Transport.send(msg);
+    }
+}
\ No newline at end of file
diff --git a/PreparedStatementNamed.java b/PreparedStatementNamed.java
new file mode 100644
index 0000000..f6830b6
--- /dev/null
+++ b/PreparedStatementNamed.java
@@ -0,0 +1,218 @@
+package tools;
+
+//import org.ccalm.main.AcceptASDCController;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class PreparedStatementNamed {
+	private static final Logger logger = LoggerFactory.getLogger(PreparedStatementNamed.class);
+
+	private class HMap{
+		public String name = "";
+		public int pos = -1;
+		public HMap(String name,int pos) {
+			this.name = name;
+			this.pos = pos;
+		}
+	}
+
+	private List< HMap > fields = new ArrayList< HMap >();
+	private PreparedStatement m_prepStmt;
+
+	public PreparedStatementNamed(Connection conn, String sql) throws SQLException {
+		int cnt=0;
+		int pos = 0;
+		while((pos = sql.indexOf("${")) != -1) {
+			int end = sql.substring(pos).indexOf("}");
+			if (end == -1)
+				end = sql.length();
+			else
+				end += pos+1;
+			cnt++;
+			fields.add(new HMap(sql.substring(pos+2,end-1),cnt));
+			sql = sql.substring(0, pos) + "?" + sql.substring(end); //Removing a parameter from a string
+		}
+		m_prepStmt = conn.prepareStatement(sql);
+	}
+	public void setString(String name, String value) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setString(fields.get(i).pos, value);
+			}
+		}
+	}
+	public void setNULLString(String name) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setNull(fields.get(i).pos,Types.NULL);
+			}
+		}
+	}
+	public void setInt(String name, String value) throws SQLException {
+		if(value==null){
+			setNULLInt(name);
+		}else {
+			for (int i = 0; i < fields.size(); i++) {
+				if (fields.get(i).name.equals(name)) {
+					m_prepStmt.setInt(fields.get(i).pos, Integer.parseInt(value));
+				}
+			}
+		}
+	}
+	public void setInt(String name, int value) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setInt(fields.get(i).pos, value);
+			}
+		}
+	}
+	public void setNULLInt(String name) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setNull(fields.get(i).pos,Types.INTEGER);
+			}
+		}
+	}
+	public void setBoolean(String name, String value) throws SQLException {
+		if(value==null){
+			setNULLBoolean(name);
+		}else {
+			for (int i = 0; i < fields.size(); i++) {
+				if (fields.get(i).name.equals(name)) {
+					if (value.equals("0") || value.equals("false") || value.equals(""))
+						m_prepStmt.setBoolean(fields.get(i).pos, false);
+					else
+						m_prepStmt.setBoolean(fields.get(i).pos, true);
+				}
+			}
+		}
+	}
+	public void setBoolean(String name, int value) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				if(value==0)
+					m_prepStmt.setBoolean(fields.get(i).pos, false);
+				else
+					m_prepStmt.setBoolean(fields.get(i).pos, true);
+			}
+		}
+	}
+	public void setNULLBoolean(String name) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setNull(fields.get(i).pos,Types.BOOLEAN);
+			}
+		}
+	}
+    /*private int getIndex(String name) {
+    	size()
+	}    */
+	public void setDouble(String name, String value) throws SQLException {
+		if(value==null){
+			setNULLDouble(name);
+		}else {
+			for (int i = 0; i < fields.size(); i++) {
+				if (fields.get(i).name.equals(name)) {
+					m_prepStmt.setDouble(fields.get(i).pos, Double.parseDouble(value));
+				}
+			}
+		}
+	}
+	public void setDouble(String name, double value) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setDouble(fields.get(i).pos, value);
+			}
+		}
+	}
+	public void setNULLDouble(String name) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setNull(fields.get(i).pos,Types.DOUBLE);
+			}
+		}
+	}
+	public void setFloat(String name, String value) throws SQLException {
+		if(value==null){
+			setNULLFloat(name);
+		}else {
+			for (int i = 0; i < fields.size(); i++) {
+				if (fields.get(i).name.equals(name)) {
+					m_prepStmt.setDouble(fields.get(i).pos, Float.parseFloat(value));
+				}
+			}
+		}
+	}
+	public void setFloat(String name, float value) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setFloat(fields.get(i).pos, value);
+			}
+		}
+	}
+	public void setNULLFloat(String name) throws SQLException {
+		for(int i=0;i<fields.size();i++) {
+			if(fields.get(i).name.equals(name)) {
+				m_prepStmt.setNull(fields.get(i).pos,Types.FLOAT);
+			}
+		}
+	}
+
+	public void setTimestamp(String name, String value) throws SQLException {
+		if(value==null){
+			for(int i=0;i<fields.size();i++) {
+				if(fields.get(i).name.equals(name)) {
+					m_prepStmt.setNull(fields.get(i).pos,Types.DATE, null);
+				}
+			}
+		}else {
+			if(value.matches("\\d+")) //If old date format in UNIX time
+			{
+				long uDate=Long.parseLong(value)+1;
+				java.sql.Timestamp tm=new java.sql.Timestamp(uDate*1000);
+				for (int i = 0; i < fields.size(); i++) {
+					if (fields.get(i).name.equals(name)) {
+						m_prepStmt.setTimestamp(fields.get(i).pos, tm);
+					}
+				}
+			}else
+			{
+				java.sql.Timestamp tm=null;
+				DateFormat dfm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //2016-05-29 18:00:01 in "GMT"
+				try{
+					tm = new java.sql.Timestamp(dfm.parse(value).getTime());
+				} catch (Exception ex) {
+					logger.error("Error",ex.getMessage());
+				}
+				for (int i = 0; i < fields.size(); i++) {
+					if (fields.get(i).name.equals(name)) {
+						m_prepStmt.setTimestamp(fields.get(i).pos, tm);
+					}
+				}
+			}
+		}
+	}
+
+
+	public PreparedStatement getPreparedStatement() {
+		return m_prepStmt;
+	}
+    /*public ResultSet executeQuery() throws SQLException {
+        return m_prepStmt.executeQuery();
+    }
+    public void close() throws SQLException {
+    	m_prepStmt.close();
+    }*/
+}
\ No newline at end of file
diff --git a/STools.java b/STools.java
new file mode 100644
index 0000000..b92250d
--- /dev/null
+++ b/STools.java
@@ -0,0 +1,39 @@
+package tools;
+
+import java.util.Iterator;
+import java.util.Map;
+
+public class STools {
+
+	public static String CutBeforeFirst(StringBuffer str,String ch)
+	{
+		int pos=str.indexOf(ch);
+		String result="";
+		if(pos==-1)
+		{
+			result.concat(str.toString());
+			str.delete(0,str.length());
+		}else
+		{
+			result=str.substring(0,pos);
+			str.delete(0,pos+1);
+		}
+		return result;
+	}
+
+	/**
+	 * Удалить из списка по значению
+	 * @param map
+	 * @param value
+	 */
+	public static void delFromMapByValue(Map<String, String> map, String value) {
+		Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
+		while (iterator.hasNext()) {
+			Map.Entry<String, String> entry = iterator.next();
+			if (entry.getValue().equalsIgnoreCase(value)) {
+				iterator.remove();
+			}
+		}
+	}
+
+}
diff --git a/Translation.java b/Translation.java
new file mode 100644
index 0000000..faae615
--- /dev/null
+++ b/Translation.java
@@ -0,0 +1,82 @@
+package tools;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.sql.*;
+
+public class Translation {
+
+    private static final Logger logger = LoggerFactory.getLogger(Translation.class);
+
+    public int language_id;
+    //public NamedParameterJdbcTemplate jdbcTemplate;
+    public Connection conn;
+    public Translation(String lng, Connection conn){
+        language_id=1;
+        switch (lng) {
+            case "kz":
+            case "kk":
+                language_id = 2;
+                break;
+            case "en":
+                language_id = 3;
+                break;
+            case "uz":
+                language_id = 4;
+                break;
+            case "ru":
+            default:
+                language_id = 1;
+                break;
+        }
+        this.conn = conn;
+    }
+
+    public String trt(String text){
+
+        boolean find = false;
+        String sql = """
+            select
+                translation
+            from
+                main._translations
+            where
+                del=false
+                and language_id=${language_id}
+                and identifier=${identifier};
+            """;
+
+        PreparedStatementNamed stmtn=null;
+        try {
+            stmtn = new PreparedStatementNamed(conn, sql);
+            stmtn.setInt("language_id", language_id);
+            stmtn.setString("identifier", text);
+        } catch (SQLException e) {
+            logger.error("Error",e);
+            e.printStackTrace();
+        }
+
+        if(stmtn!=null){
+            PreparedStatement stmt=stmtn.getPreparedStatement();
+            ResultSet rs = null;
+            try {
+                rs = stmt.executeQuery();
+                while (rs.next()) {
+                    text = rs.getString(1);
+                    find = true;
+                }
+            } catch (SQLException e) {
+                logger.error("Error",e);
+                e.printStackTrace();
+            }finally{
+                try { if (rs != null) rs.close(); } catch (Exception e) {};
+                try { if (stmt != null) stmt.close(); } catch (Exception e) {};
+            }
+        }
+
+        if(!find){
+            text = text.replace("_", " ");
+        }
+        return text;
+    }
+}
diff --git a/User.java b/User.java
new file mode 100644
index 0000000..5e9ec22
--- /dev/null
+++ b/User.java
@@ -0,0 +1,45 @@
+package tools;
+
+public class User {
+	
+	public String id; //User id from database
+	public String name; //Name Surname Patronymic
+	public String language_id; //User language
+	public String role; //User role
+	public String country_id; //User role
+	
+	public User()
+	{
+		id="null"; //null так как заменяю в SQL строке строку вида ${_user_id} на цифровое значение 
+		name="___";
+		language_id="1";
+		role="___";
+		country_id="";
+	}
+	public User(String name)
+	{
+		super();
+		id="null";
+		this.name=name;
+		language_id="1";
+		role="___";
+		country_id="";
+	}
+	public void setName(String name)
+	{
+		this.name=name;
+	}
+	public String getName()
+	{
+		return name; 
+	}
+	public void Logout()
+	{
+		id="null";
+		name="___";
+		language_id="1";
+		role="___";
+		country_id="";		
+	}
+}
+
diff --git a/XMLTools.java b/XMLTools.java
new file mode 100644
index 0000000..e7ae2f7
--- /dev/null
+++ b/XMLTools.java
@@ -0,0 +1,189 @@
+package tools;
+
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpression;
+
+import org.w3c.dom.CharacterData;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpression;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+public class XMLTools 
+{
+	/**
+	 * Вернуть значение первой попавшийся CDATA
+	 * @return строка
+	 */
+	public static String getCDATAValue(Node node)
+	{
+		if(node==null) return "";
+		NodeList items = node.getChildNodes();
+		for (int i=0;i<items.getLength();i++)
+		{
+			Node n=items.item(i);
+			if(n.getNodeName().equals("#cdata-section"))
+				return n.getNodeValue();
+		}
+		return "";
+	}
+
+	/** Найти узел по атрибуту
+	 */
+	public static Node findNodeOnAttribute(Node node, String nodename, String attribute, String val)
+	{
+		if(node==null) return null;
+		NodeList items = node.getChildNodes();
+		for (int i=0;i<items.getLength();i++)
+		{
+			Node n=items.item(i);
+			if(n.getNodeName().equals(nodename))
+			{
+				NamedNodeMap nnm=n.getAttributes();
+	        	if(nnm.getNamedItem(attribute).getNodeValue().equals(val)) return n;   
+			}
+		}
+		return null;
+	}
+	
+	public static Node findFirstNodeOnAttribute(Node node, String nodename,String attribute,String val)
+	{
+		Node result=null;
+		if(node==null) return result;
+		javax.xml.xpath.XPathFactory xPathfactory = javax.xml.xpath.XPathFactory.newInstance();
+		XPath xpath = xPathfactory.newXPath();
+		XPathExpression expr=null;
+		Object exprResult=null;
+		try {
+			expr = xpath.compile("//*/"+nodename+"[@"+attribute+"='" + val + "']");
+			exprResult = expr.evaluate(node, XPathConstants.NODESET);
+		} catch (XPathExpressionException ex) {
+			
+		}
+		NodeList nodeList = (NodeList) exprResult;
+		if (nodeList.getLength() > 0)
+			result = nodeList.item(0);
+		return result;
+	}
+
+	/**
+	 * Поиск среди текущего и дочерних узлов
+	 * @param {Node} node Корневой узел
+	 * @param {String} nodename Имя первого попавшегося узла 
+	 * @returns {undefined}
+	 */
+	public static Node findFirstNode(Node node, String nodename)
+	{
+		Node result=null;
+		if(node==null) return result;
+		javax.xml.xpath.XPathFactory xPathfactory = javax.xml.xpath.XPathFactory.newInstance();
+		XPath xpath = xPathfactory.newXPath();
+		XPathExpression expr=null;
+		Object exprResult=null;
+		try {
+			expr = xpath.compile("//*/"+nodename);
+			exprResult = expr.evaluate(node, XPathConstants.NODESET);
+		} catch (XPathExpressionException ex) {
+			
+		}
+		NodeList nodeList = (NodeList) exprResult;
+		if (nodeList.getLength() > 0)
+			result = nodeList.item(0);
+		return result;
+	}
+	
+	/**
+	 * Присвоить дочерние узлы первого дерева второму если их нет, иначе дополнить либо заменить. (Работает через рекурсию нужно для передачи параметров между окнами)
+	 * @param {XML} first Узел где ханятся настройки
+	 * @param {XML} second Узел к которому применяются настройки
+	 * @param {String} name Имя атрибута по которому будут находиться одинаковые XML узлы
+	 * @returns {undefined}
+	 */
+	public static void applyNodeToNode(Node first, Node second,String name)
+	{		
+		if(first==null || second==null || name==null) return;
+		
+		//Если есть совпадающие узлы то передаём в рекурсию если нет то просто копируем
+		Node fn=first.getFirstChild();
+		while (fn != null)
+		{		
+			Node sn=null;
+			if(!fn.getNodeName().equals("#text") && !fn.getNodeName().equals("#cdata-section") && !fn.getNodeName().equals("#comment")) { //потому что для этих getAttribute вызывает ошибку
+				sn=findNodeOnAttribute(second,fn.getNodeName(),name,fn.getAttributes().getNamedItem(name).getNodeValue());
+			}
+
+			if(sn!=null) //Если по имени атрибуту совпали узлы
+			{
+				//Переписываем значения атрибутов из первого второму, если их нет то создаём.
+				for(int i=0;i<fn.getAttributes().getLength();i++)
+				{
+					Element el=(Element) sn;
+					el.setAttribute(fn.getAttributes().item(i).getNodeName(),fn.getAttributes().item(i).getNodeValue());
+				}
+				applyNodeToNode(fn,sn,name); //В рекурсию
+			}
+			else
+			{
+				//Значения CDADA или text node не должны накапливаться их мы пересоздаём (потом по момеру можно сделать 1й заменяется первым итд.)
+				if(fn.getNodeName().equals("#cdata-section"))
+				{
+					XMLTools.setCharacterDataToElement((Element)second, XMLTools.getCharacterDataFromElement((Element) fn)); //getCdata(second).nodeValue = fn.nodeValue;
+				}else
+				{	
+					second.appendChild(fn.cloneNode(true));
+				}
+			}
+			fn=fn.getNextSibling();
+		}
+	}
+	
+	/**
+	 * Найти узел по имени
+	 * @param node
+	 * @param nodename
+	 * @return
+	 */
+	public static Node findNode(Node node, String nodename)
+	{
+		if(node==null || nodename==null) return null;
+		NodeList items = node.getChildNodes();
+		for (int i=0;i<items.getLength();i++)
+		{
+			Node n=items.item(i);
+			if(n.getNodeName().equals(nodename))
+			{
+				return n;   
+			}
+		}
+		return null;
+	}
+	
+	public static String getCharacterDataFromElement(Element e) {
+		Node child = e.getFirstChild();
+		if (child instanceof CharacterData) {
+			CharacterData cd = (CharacterData) child;
+			return cd.getData().trim();
+		}
+		return "";
+	}
+
+	public static void setCharacterDataToElement(Node nF, String data) {
+		Node child = nF.getFirstChild();
+		if (child instanceof CharacterData) {
+			CharacterData cd = (CharacterData) child;
+			cd.setData(data);
+		} else //Create new CDATA node
+		{
+			Document doc = nF.getOwnerDocument();
+			nF.appendChild(doc.createCDATASection(data));
+		}
+	}
+
+}
diff --git a/tctable/Point.java b/tctable/Point.java
new file mode 100644
index 0000000..c212768
--- /dev/null
+++ b/tctable/Point.java
@@ -0,0 +1,14 @@
+/**
+ * Created by IntelliJ IDEA.
+ * User: igor
+ * Date: 09.03.2007
+ * Time: 0:53:45
+ * To change this template use File | Settings | File Templates.
+ */
+package tctable;
+
+public class Point
+{
+    public double x=0;
+    public double y=0;
+}
\ No newline at end of file
diff --git a/tctable/TCField.java b/tctable/TCField.java
new file mode 100644
index 0000000..1e9cb19
--- /dev/null
+++ b/tctable/TCField.java
@@ -0,0 +1,574 @@
+package tctable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.math.BigDecimal;
+
+public class TCField
+{
+	//Типы данных
+	public static final int BD_NULL = 1000; //Столбец со значением всегда NULL
+	public static final int BD_UINT1 = 0; //1 байт без знаковый
+	public static final int BD_UINT2 = 1; //2 байта без знаковый
+	public static final int BD_UINT4 = 3; //4 байта без знаковый
+	public static final int BD_UINT8 = 23; //8 байта без знаковый
+	public static final int BD_SUINT8 = 24; //Почти тоже самое что и BD_UTF8_1 но с строке передаётся число
+	public static final int BD_INT1 = 10; //1 байт со знаковый
+	public static final int BD_INT2 = 11; //2 байта со знаковый
+	public static final int BD_INT4 = 13; //4 байта со знаковый
+	public static final int BD_INT8 = 17; //8 байт со знаковый
+	public static final int BD_SINT8 = 25; //Почти тоже самое что и BD_UTF8_1 но с строке передаётся число
+	public static final int BD_FLOAT4 = 20; //4 байта
+	public static final int BD_FLOAT8 = 22; //8 байт double
+	public static final int BD_SFLOAT8 = 26; //Почти тоже самое что и BD_UTF8_1 но с строке передаётся число
+	public static final int BD_UTF8_1 = 100; //100 - utf8_1 string 1й байт размер строки в байтах
+	public static final int BD_UTF8_2 = 101; //101 - utf8_2 string 1х 2 байта размер строки в байтах
+	public static final int BD_UTF8_4 = 102; //102 - utf8_4 string 1х 4 байта размер строки в байтах
+	public static final int BD_BLOB_2 = 141;
+	public static final int BD_BLOB_4 = 143; //Двоичные данные uint4 количество байт
+
+	public String name=""; //Название столбца
+	public int type=-1; //Тип данных
+	public byte[] value=null; //Запакованые данные
+
+	public TCField(String name, int type)
+	{
+		this.name=name;
+		this.type=type;
+	}
+	
+	public TCField(String name, String type)
+	{
+		this.name=name;
+		//this.type=type;
+		
+		this.type= TCField.BD_UTF8_2; //Defalt type
+		//From PostgreSQL and MySQL
+		if(type.equals("null")) { this.type= TCField.BD_NULL; } else
+		if(type.equals("bool") || type.equals("tinyint")) { this.type= TCField.BD_UINT1; } else
+		if(type.equals("int4") || type.equals("int") || type.equals("serial") || type.equals("bigint")) { this.type= TCField.BD_INT4; } else //bigint немного неправильно потому что это 64 бита но для андрод приложения не сделал
+		if(type.equals("int8")) { this.type= TCField.BD_INT8; } else
+		if(type.equals("float4") || type.equals("float")) { this.type= TCField.BD_FLOAT4; } else
+		if(type.equals("float8") || type.equals("NUMBER")) { this.type= TCField.BD_FLOAT8; } else
+		if(type.equals("varchar") || type.equals("VARCHAR2")) { this.type= TCField.BD_UTF8_2; } else
+		if(type.equals("text")) { this.type= TCField.BD_UTF8_4; } else
+		if(type.equals("bytea") || type.equals("longblob")) { this.type= TCField.BD_BLOB_4; } else
+		if(type.equals("timestamptz")) { this.type= TCField.BD_UTF8_1; } else
+		if(type.equals("timestamp")) { this.type= TCField.BD_UTF8_1; } else
+		if(type.equals("date")) { this.type= TCField.BD_UTF8_1; }
+	}
+
+	private int byteArrayToInt(byte[] b, int start, int length)
+	{
+		int dt = 0;
+		if ((b[start] & 0x80) != 0)
+			dt = Integer.MAX_VALUE;
+		for (int i = 0; i < length; i++)
+			dt = (dt << 8) + (b[start++] & 255);
+		return dt;
+	}
+
+/*
+	private byte[] intToByteArray(int n, int byteCount)
+	{
+		byte[] res = new byte[byteCount];
+		for (int i = 0; i < byteCount; i++)
+			res[byteCount - i - 1] = (byte) ((n >> i * 8) & 255);
+		return res;
+	}
+*/
+
+	//Прочитать значение из потока в соответствии с типом
+	public void ReadValue(InputStream fileHandle) throws IOException
+	{
+		if(this.type== TCField.BD_UINT1)
+		{
+			value=new byte[1];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_UINT2)
+		{
+			value=new byte[2];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_UINT4)
+		{
+			value=new byte[4];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_UINT8)
+		{
+			value=new byte[8];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_INT1)
+		{
+			value=new byte[1];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_INT2)
+		{
+			value=new byte[2];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_INT4)
+		{
+			value=new byte[4];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_INT8)
+		{
+			value=new byte[8];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_FLOAT4)
+		{
+			value=new byte[4];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_FLOAT8)
+		{
+			value=new byte[8];
+			fileHandle.read(value);
+		}else
+		if(this.type== TCField.BD_UTF8_1 || this.type== TCField.BD_SUINT8 || this.type== TCField.BD_SINT8 || this.type== TCField.BD_SFLOAT8)
+		{
+			byte[] s=new byte[1];
+			fileHandle.read(s);
+			if(s[0]==0) value=null;
+			else
+			{
+				value=new byte[s[0]];
+				fileHandle.read(value);
+			}
+		}else
+		if(this.type== TCField.BD_UTF8_2)
+		{
+			int s=Tools.readUShort(fileHandle);
+			if(s==0) value=null;
+			else
+			{
+				value=new byte[s];
+				fileHandle.read(value);
+			}
+		}else
+		if(this.type== TCField.BD_UTF8_4)
+		{
+			long s=Tools.readUInt(fileHandle);
+			if(s==0) value=null;
+			else
+			{
+				value=new byte[(int)s];
+				fileHandle.read(value);
+			}
+		}else
+		if(this.type== TCField.BD_BLOB_4)
+		{	
+			byte[] ss=new byte[4];
+			fileHandle.read(ss);
+			int s=byteArrayToInt(ss, 0, 4);
+			if(s==0) value=null;
+			else
+			{
+				value=new byte[s];
+				fileHandle.read(value);
+			}
+		}
+	}
+
+	public String getStrVal()
+	{
+		String result=null;
+		try
+		{
+			if(value==null) result = "";
+			if(type== TCField.BD_UINT1) result = String.valueOf(getUByteVal());
+			if(type== TCField.BD_UINT4) result = String.valueOf(getUIntVal());
+			if(type== TCField.BD_UINT8) result = String.valueOf(getULongVal());
+			if(type== TCField.BD_INT4) result = String.valueOf(getIntVal());
+			if(type== TCField.BD_INT8) result = String.valueOf(getLongVal());
+			if(type== TCField.BD_FLOAT4) result = String.valueOf(getFloatVal());
+			if(type== TCField.BD_FLOAT8) result = String.valueOf(getDoubleVal());
+			if(type== TCField.BD_UTF8_1 || type== TCField.BD_UTF8_2 || type== TCField.BD_UTF8_4 || type== TCField.BD_SUINT8 || type== TCField.BD_SINT8 || type== TCField.BD_SFLOAT8)
+			{
+				result = new String(value, "UTF8");
+			}
+		} catch (Exception e) {}
+		return result;
+	}
+
+	public boolean getBoolVal(){
+		String result=getStrVal();
+		if(result==null)
+			return false;
+		else {
+			result=result.toLowerCase();
+			if (result.equals("1") || result.equals("true") || result.equals("t"))
+				return true;
+			else
+				return false;
+		}
+	}
+	public int getIntVal()
+	{
+		int val=0;
+		if(type==BD_INT4) {
+			int i1 = value[0] & 0xff;
+			int i2 = value[1] & 0xff;
+			int i3 = value[2] & 0xff;
+			int i4 = value[3] & 0xff;
+			val = i4 << 24 | i3 << 16 | i2 << 8 | i1;
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Integer.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public long getLongVal()
+	{
+		long val=0;
+		if(type==BD_INT8) {
+			long ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
+			ch1 = value[0] & 0xff;
+			ch2 = value[1] & 0xff;
+			ch3 = value[2] & 0xff;
+			ch4 = value[3] & 0xff;
+			ch5 = value[4] & 0xff;
+			ch6 = value[5] & 0xff;
+			ch7 = value[6] & 0xff;
+			ch8 = value[7] & 0xff;
+			val = (ch8 << 56) | (ch7 << 48) | (ch6 << 40) | (ch5 << 32) | (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Long.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	/** Пока не использую но если буду использовать протестировать с большими числами */
+	public long getUIntVal()
+	{
+		long val=0;
+		if(type==BD_UINT4) {
+			long ch1, ch2, ch3, ch4;
+			ch1 = value[0] & 0xff;
+			ch2 = value[1] & 0xff;
+			ch3 = value[2] & 0xff;
+			ch4 = value[3] & 0xff;
+			val = (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Long.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public long getULongVal()
+	{
+		long val=0;
+		if(type==BD_UINT8) {
+			long ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
+			ch1 = value[0] & 0xff;
+			ch2 = value[1] & 0xff;
+			ch3 = value[2] & 0xff;
+			ch4 = value[3] & 0xff;
+			ch5 = value[4] & 0xff;
+			ch6 = value[5] & 0xff;
+			ch7 = value[6] & 0xff;
+			ch8 = value[7] & 0xff;
+			val = (ch8 << 56) | (ch7 << 48) | (ch6 << 40) | (ch5 << 32) | (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Long.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public short getUByteVal()
+	{
+		short val=0;
+		if(type==BD_UINT1) {
+			val = (short) (value[0] & 0xff);
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Short.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public float getFloatVal()
+	{
+		float val=0;
+		if(type==BD_FLOAT4) {
+			int ch1, ch2, ch3, ch4, count;
+			ch1 = value[0] & 0xFF;
+			ch2 = value[1] & 0xFF;
+			ch3 = value[2] & 0xFF;
+			ch4 = value[3] & 0xFF;
+
+			count = (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+			val = Float.intBitsToFloat(count);
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Float.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public double getDoubleVal()
+	{
+		double val=0;
+		if(type==BD_FLOAT8) {
+			int ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
+			long count;
+			ch1 = value[0] & 0xFF;
+			ch2 = value[1] & 0xFF;
+			ch3 = value[2] & 0xFF;
+			ch4 = value[3] & 0xFF;
+			ch5 = value[4] & 0xFF;
+			ch6 = value[5] & 0xFF;
+			ch7 = value[6] & 0xFF;
+			ch8 = value[7] & 0xFF;
+			count = ((long) ch8 << 56) |
+					((long) ch7 << 48) |
+					((long) ch6 << 40) |
+					((long) ch5 << 32) |
+					((long) ch4 << 24) |
+					((long) ch3 << 16) |
+					((long) ch2 << 8) |
+					ch1;
+			val = Double.longBitsToDouble(count);
+		}else{
+			String sVal = getStrVal();
+			if(sVal!=null) {
+				try {
+					val = Double.valueOf(sVal);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		return val;
+	}
+
+	public boolean setDoubleVal(Double v){
+		long iv= Double.doubleToLongBits(v);
+		value=new byte[8];
+		value[0] = (byte)((iv & 0x00000000000000ffl));
+		value[1] = (byte)((iv & 0x000000000000ff00l) >> 8);
+		value[2] = (byte)((iv & 0x0000000000ff0000l) >> 16);
+		value[3] = (byte)((iv & 0x00000000ff000000l) >> 24);
+		value[4] = (byte)((iv & 0x000000ff00000000l) >> 32);
+		value[5] = (byte)((iv & 0x0000ff0000000000l) >> 40);
+		value[6] = (byte)((iv & 0x00ff000000000000l) >> 48);
+		value[7] = (byte)((iv & 0xff00000000000000l) >> 56);
+		return true;
+	}
+
+	public boolean setValue(String val)
+	{
+		boolean result=true;
+		if(val==null)
+		{	value=null;
+		}else if(type== TCField.BD_UINT1)
+		{
+			if(val.equals("f") || val.equals("false")) val="0";
+			else if(val.equals("t") || val.equals("true")) val="1";
+				
+			int v= Integer.parseInt(val);
+			if(v<0 ||  v>255) result=false;
+			value=new byte[1];
+			value[0]=(byte)v;
+		}else if(type== TCField.BD_UINT2)
+		{
+			int v= Integer.parseInt(val);
+			if(v<0 ||  v>65535) result=false;			
+			value=new byte[2];
+			value[0] = (byte)((v & 0x000000ff));
+			value[1] = (byte)((v & 0x0000ff00) >> 8);
+		}else if(type== TCField.BD_UINT4)
+		{
+			long v= Long.parseLong(val);
+			value=new byte[4];
+			value[0] = (byte)((v & 0x000000ff));
+			value[1] = (byte)((v & 0x0000ff00) >> 8);
+			value[2] = (byte)((v & 0x00ff0000) >> 16);
+			value[3] = (byte)((v & 0xff000000) >> 24);			
+		}else if(type== TCField.BD_UINT8)
+		{
+			long v= Long.parseLong(val);
+			value=new byte[8];
+			value[0] = (byte) (v & 0x00000000000000ffl);
+			value[1] = (byte)((v & 0x000000000000ff00l) >> 8);
+			value[2] = (byte)((v & 0x0000000000ff0000l) >> 16);
+			value[3] = (byte)((v & 0x00000000ff000000l) >> 24);
+			value[4] = (byte)((v & 0x000000ff00000000l) >> 32);
+			value[5] = (byte)((v & 0x0000ff0000000000l) >> 40);
+			value[6] = (byte)((v & 0x00ff000000000000l) >> 48);
+			value[7] = (byte)((v & 0xff00000000000000l) >> 56);
+		}else if(type== TCField.BD_INT1)
+		{
+			int v= Integer.parseInt(val);
+			value=new byte[1];
+			value[0]=(byte)v;
+		}else if(type== TCField.BD_INT2)
+		{
+			int v= Integer.parseInt(val);
+			value=new byte[2];
+			value[0] = (byte)((v & 0x000000ff));
+			value[1] = (byte)((v & 0x0000ff00) >> 8);
+		}else if(type== TCField.BD_INT4)
+		{
+			long v= Long.parseLong(val);
+			value=new byte[4];
+			value[0] = (byte)((v & 0x000000ff));
+			value[1] = (byte)((v & 0x0000ff00) >> 8);
+			value[2] = (byte)((v & 0x00ff0000) >> 16);
+			value[3] = (byte)((v & 0xff000000) >> 24);			
+		}else if(type== TCField.BD_INT8)
+		{
+			long v= Long.parseLong(val);
+			value=new byte[8];
+			value[0] = (byte) (v & 0x00000000000000ffl);
+			value[1] = (byte)((v & 0x000000000000ff00l) >> 8);
+			value[2] = (byte)((v & 0x0000000000ff0000l) >> 16);
+			value[3] = (byte)((v & 0x00000000ff000000l) >> 24);
+			value[4] = (byte)((v & 0x000000ff00000000l) >> 32);
+			value[5] = (byte)((v & 0x0000ff0000000000l) >> 40);
+			value[6] = (byte)((v & 0x00ff000000000000l) >> 48);
+			value[7] = (byte)((v & 0xff00000000000000l) >> 56);
+		}else if(type== TCField.BD_FLOAT4)
+		{
+			Float v= Float.parseFloat(val);
+			int iv= Float.floatToIntBits(v);
+			
+			value=new byte[4];
+			value[0] = (byte)((iv & 0x000000ff));
+			value[1] = (byte)((iv & 0x0000ff00) >> 8);
+			value[2] = (byte)((iv & 0x00ff0000) >> 16);
+			value[3] = (byte)((iv & 0xff000000) >> 24);
+		}else if(type== TCField.BD_FLOAT8)
+		{
+			setDoubleVal(Double.parseDouble(val));
+		}else if(type== TCField.BD_UTF8_1 || this.type== TCField.BD_SUINT8 || this.type== TCField.BD_SINT8 || this.type== TCField.BD_SFLOAT8)
+		{
+			value=null;
+			if(val!=null && !val.equals(""))
+			{
+				byte[] b=null;
+				try {
+					b = val.getBytes("UTF-8");
+				} catch (UnsupportedEncodingException e) {
+					result=false;
+				}
+				if(b!=null)
+				{			
+					int len=b.length;
+					if(len>255) len=255;	
+					value=new byte[len+1];
+					value[0]=(byte)len;
+					for(int i=0;i<len;i++)
+					{
+						value[i+1]=b[i];
+					}
+				}
+			}			
+		}else if(type== TCField.BD_UTF8_2)
+		{
+			value=null;
+			if(val!=null && !val.equals(""))
+			{
+				byte[] b=null;
+				try {
+					b = val.getBytes("UTF-8");
+				} catch (UnsupportedEncodingException e) {
+					result=false;
+				}
+				if(b!=null)
+				{			
+					int len=b.length;
+					if(len>65535) len=65535;	
+					value=new byte[len+2];
+					value[0]=(byte) (len & 0x000000ff);
+					value[1]=(byte)((len & 0x0000ff00) >> 8);
+					for(int i=0;i<len;i++)
+					{
+						value[i+2]=b[i];
+					}
+				}
+			}			
+		}else if(type== TCField.BD_UTF8_4)
+		{
+			value=null;
+			if(val!=null && !val.equals(""))
+			{
+				byte[] b=null;
+				try {
+					b = val.getBytes("UTF-8");
+				} catch (UnsupportedEncodingException e) {
+					result=false;
+				}
+				if(b!=null)
+				{			
+					int len=b.length;
+					value=new byte[len+4];					
+					value[0]=(byte) (len & 0x000000ff);
+					value[1]=(byte)((len & 0x0000ff00) >> 8);
+					value[2]=(byte)((len & 0x00ff0000) >> 16);
+					value[3]=(byte)((len & 0xff000000) >> 24);
+					for(int i=0;i<len;i++)
+					{
+						value[i+4]=b[i];
+					}
+				}
+			}			
+		}
+		return result;
+	}
+	public boolean isNull() {
+		return value==null;
+	}
+
+	public BigDecimal getBigDecimalVal() {
+		BigDecimal val=new BigDecimal("0");
+		String sVal = getStrVal();
+		if(sVal!=null) {
+			try {
+				val = new BigDecimal(sVal);
+			} catch (NumberFormatException e) {
+			}
+		}
+		return val;
+	}
+}
diff --git a/tctable/TCTable.java b/tctable/TCTable.java
new file mode 100644
index 0000000..bfed7c1
--- /dev/null
+++ b/tctable/TCTable.java
@@ -0,0 +1,200 @@
+package tctable;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class TCTable 
+{
+	public int id=0; //Идентификатор таблицы
+	public String name=""; //Название таблицы
+	public List<TCField> fields=new ArrayList<TCField>(); //Список полей
+
+	private int nc=0; //Байтов под NULL значения
+	private byte[] m_NULL=null; //NULL значения
+	private InputStream m_file;
+
+	/**
+	 * Конструктор
+	 * @param Строка name Название таблицы
+	 * @param Целое id Идентификатор таблицы (обычно уникальный)
+	 */
+	public TCTable(String name, int id)
+	{	this.name=name;
+		this.id=id;
+	}
+
+	//Открыть таблицу по названию файла
+	/*function OpenTableF(file)
+	{
+		if(file_exists(file))
+		{
+			this.OpenTableH(fopen(file,'r'));
+		}
+	}*/
+
+	//Открыть таблицу из потока HANDLE
+	public boolean OpenTableH(InputStream handle) throws IOException
+	{
+		this.m_file=handle;
+		DataInputStream dis = new DataInputStream(handle);
+
+		if(Tools.readUShort(dis)!=65500) return false; //id файла
+		if(Tools.readUShort(dis)!=1) return false; //Версия файла
+		this.id= Tools.readInt(dis); //ID таблицы или запроса (4 байта можно сделать 2)
+		if(dis.readByte()!=0) return false; //Только плотные таблицы
+		//Считываем название таблицы
+		this.name = Tools.readUTF8_1(dis);
+
+		//Считываем столбцы
+		int count=dis.readUnsignedByte(); //Количество столбцов
+		for(int i=0;i<count;i++)
+		{
+			TCField field=new TCField(Tools.readUTF8_1(dis), dis.readUnsignedByte());
+			this.addField(field);
+		}
+		return true;
+	}
+	//Открыть таблицу из потока
+	//OpenTable
+
+	//Прочитать следующую запись из потока
+	public boolean ReadNextRecord()
+	{
+		Boolean result=true;
+		try
+		{
+			DataInputStream dis = new DataInputStream(m_file);
+			//if(m_file.available()) return false; //Неработает
+	
+			if(dis.available()==0)
+				return false;
+	
+			//Считываем NULL значения
+			if(m_NULL==null) m_NULL = new byte[nc];
+			for(int i=0;i<nc;i++)
+			{
+				m_NULL[i]=(byte)dis.readUnsignedByte();
+			}
+	
+			clearRows();
+			for(int i=0;i<fields.size();i++)
+			{
+				if(Tools.getBit(m_NULL,i))
+				{
+					fields.get(i).ReadValue(m_file);
+				}
+			}
+		}catch(Exception e)
+		{
+			result=false;
+		}
+		return result;
+	}
+
+	//Добавить поле к таблице
+	public void addField(TCField field)
+	{	if(field!=null)
+		{	fields.add(field);
+			this.nc=(int) Math.ceil(fields.size()/8.0); //Байтов под NULL
+			m_NULL=new byte[nc];
+		}
+	}
+
+	//Получить заголовок плотной таблицы в виде двоичной строки
+	public boolean getHeader(OutputStream os)
+	{
+		boolean result=true;
+		try {
+			//File ID: 2 bytes.
+			os.write((65500 & 0x000000ff));
+			os.write((65500 & 0x0000ff00) >> 8);
+			//File version: 2 bytes.
+			os.write((1 & 0x000000ff));
+			os.write((1 & 0x0000ff00) >> 8);	
+			//Table ID (or Request ID): 4 bytes.
+			os.write((this.id & 0x000000ff));
+			os.write((this.id & 0x0000ff00) >> 8);
+			os.write((this.id & 0x00ff0000) >> 16);
+			os.write((this.id & 0xff000000) >> 24);
+			//Table type: 1 byte (0- "Dense" 1- "Loose")
+			os.write(0);
+			//UTF8_1 String
+			byte[] ba = this.name.getBytes("UTF-8");
+			os.write(ba.length);
+			os.write(ba);
+			//Count of fields: 1 byte.
+			os.write(this.fields.size());
+			//Write name and type id
+			for(int i=0;i<this.fields.size();i++)
+			{
+				ba = this.fields.get(i).name.getBytes("UTF-8");
+				os.write(ba.length);
+				os.write(ba);
+				os.write(this.fields.get(i).type);
+			}
+		} catch (IOException e) {
+			result=false;
+		}
+		return result;
+	}
+	
+	//Получить данные 1 записи в виде строки
+	public boolean getCol(OutputStream os)
+	{
+		boolean result=true;
+		//Запишем NULL значения побайтно (1-есть данные 0-нету данных)
+		int nc=(int) Math.ceil(fields.size()/8.0); //Байтов под NULL
+		byte[] fNULL=new byte[nc];
+		for(int i=0;i<nc*8;i++)
+		{
+			if(i<this.fields.size() && this.fields.get(i).value!=null)
+			{
+				Tools.setBit(fNULL,i);
+			}
+		}
+		//Write NULL fields
+		try {
+			os.write(fNULL);
+		} catch (IOException e1) {
+			result=false;
+		}
+		//Запишем сами данные в строку
+		for(int i=0;i<fields.size();i++)
+		{
+			try {
+				if(fields.get(i).value!=null)
+					os.write(fields.get(i).value);
+			} catch (IOException e) {
+				result=false;
+			}
+		}
+		return result;
+	}
+
+	//Row очистить запись
+	void clearRows()
+	{	for(int i=0;i<fields.size();i++)
+		{
+			fields.get(i).value=null;
+		}
+	}
+
+	//Получить обьект столбца по имени
+	public TCField getRowByName(String name)
+	{	for(int i=0;i<fields.size();i++)
+		{	if(fields.get(i).name.toUpperCase().equals(name.toUpperCase())) return fields.get(i);
+		}
+		return null;
+	}
+
+	//Получить объект столбца по номеру
+	TCField getRowByNum(int num)
+	{	return fields.get(num);
+	}
+
+}
diff --git a/tctable/TCTableTools.java b/tctable/TCTableTools.java
new file mode 100644
index 0000000..5bdce52
--- /dev/null
+++ b/tctable/TCTableTools.java
@@ -0,0 +1,74 @@
+package tctable;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.sql.*;
+import java.util.HashMap;
+import java.util.Map;
+
+//В андроид не используется данный класс
+public class TCTableTools {
+
+    //Записать таблицу в OutputStream
+    public static boolean getTCTableFromResultSet(String name, int id, ResultSet rs, OutputStream os){
+        TCTable tbl=new TCTable(name,id);
+        try {
+            ResultSetMetaData rsmd = rs.getMetaData();
+            for(int i=1;i<=rsmd.getColumnCount();i++)
+            {
+                TCField field = new TCField(rsmd.getColumnName(i), rsmd.getColumnTypeName(i));
+                tbl.addField(field);
+            }
+            tbl.getHeader(os);
+            while (rs.next())
+            {
+                for(int i=1;i<=rsmd.getColumnCount();i++)
+                {
+                    if(rsmd.getColumnTypeName(i).equals("geometry")) { //Геометрию не сохраняю пока не знаю как лучьше сохранять
+                        tbl.fields.get(i - 1).setValue(null);
+                    }else {
+                        tbl.fields.get(i - 1).setValue(rs.getString(i));
+                    }
+                }
+                tbl.getCol(os);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    //Напиши функцию: Получить ассоциативный массив название полей таблицы и их тип
+    public static Map<String, String> getTableSchema(Connection connection, String schemaName, String tableName) {
+        Map<String, String> schemaMap = new HashMap<>();
+        String query = """
+                SELECT c.column_name, 
+                       CASE 
+                           WHEN t.typtype = 'e' THEN 'enum' 
+                           WHEN t.typname = 'USER-DEFINED' THEN 
+                               (SELECT pt.typname FROM pg_type pt WHERE pt.oid = c.udt_name::regtype::oid) 
+                           ELSE t.typname 
+                       END as data_type 
+                FROM information_schema.columns c 
+                JOIN pg_type t ON c.udt_name = t.typname 
+                WHERE c.table_schema = ? 
+                AND c.table_name = ?
+                """;
+        try (PreparedStatement statement = connection.prepareStatement(query)) {
+            statement.setString(1, schemaName);
+            statement.setString(2, tableName);
+            try (ResultSet resultSet = statement.executeQuery()) {
+                while (resultSet.next()) {
+                    String columnName = resultSet.getString("column_name");
+                    String columnType = resultSet.getString("data_type");
+                    schemaMap.put(columnName, columnType);
+                }
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return schemaMap;
+    }
+
+}
diff --git a/tctable/Tools.java b/tctable/Tools.java
new file mode 100644
index 0000000..db48d39
--- /dev/null
+++ b/tctable/Tools.java
@@ -0,0 +1,2529 @@
+package tctable;
+
+//import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.io.UnsupportedEncodingException;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+public class Tools {
+
+	public static String readStringFromInputStream(InputStream inputStream) {
+		ByteArrayOutputStream result = new ByteArrayOutputStream();
+		byte[] buffer = new byte[1024];
+		int length;
+		try {
+			while ((length = inputStream.read(buffer)) != -1) {
+			    result.write(buffer, 0, length);
+			}
+		} catch (IOException e1) {
+			e1.printStackTrace();
+		}
+		// StandardCharsets.UTF_8.name() > JDK 7
+		try {
+			return result.toString("UTF-8");
+		} catch (UnsupportedEncodingException e) {
+		}
+		return "";
+	}
+
+	public static int countOccurrences(String str, char symbol) {
+		int count = 0;
+		for (int i = 0; i < str.length(); i++) {
+			if (str.charAt(i) == symbol) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	//Преобразовать арабские и индийские в современные цифры
+	public static String numConvert(String str)
+	{
+		if(str==null) return null;
+		String persian = "۰۱۲۳۴۵۶۷۸۹";
+	    String arabic = "٩٨٧٦٥٤٣٢١٠";
+	    String num = "0123456789";
+	    //Заменяю персидские
+	    for(int i=0;i<str.length();i++)
+	    {
+	    	for(int j=0;j<persian.length();j++)
+	    	{
+	    		if(str.charAt(i)==persian.charAt(j))
+	    		{
+	    			str = str.substring(0,i) + num.charAt(j) + str.substring(i+1);
+	    			break;
+	    		}
+	    	}
+	    }
+	    //Заменяю арабские
+	    for(int i=0;i<str.length();i++)
+	    {
+	    	for(int j=0;j<arabic.length();j++)
+	    	{
+	    		if(str.charAt(i)==arabic.charAt(j))
+	    		{
+	    			str = str.substring(0,i) + num.charAt(j) + str.substring(i+1);
+	    			break;
+	    		}
+	    	}
+	    }	    
+	    return str;
+	}
+
+	public static boolean isEmailValid(String email) {
+		String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
+		Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
+		Matcher matcher = pattern.matcher(email);
+		return matcher.matches();
+	}
+
+//	public static boolean isNetworkConnected(Context context) {
+//		ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+//		return cm.getActiveNetworkInfo() != null && cm.getActiveNetworkInfo().isConnected();
+//	}
+
+	//Этот запрос нельзя выполнять в главном потоке
+	public static boolean isInternetAvailable() {
+		try {
+			InetAddress ipAddr = InetAddress.getByName("google.com");
+			//InetAddress ipAddr = InetAddress.getByName("geovizor.com");
+			//You can replace it with your name
+			return !ipAddr.equals("");
+		} catch (Exception ex) {
+			return false;
+		}
+	}
+
+	//Получить бит по его номеру нумерация лева на право
+	public static boolean getBit(byte[] mas, int pos)
+	{
+		int n=(int) Math.floor(pos/8.0);
+		int b=mas[n];
+		pos=pos - n * 8;
+		if(((b << pos) & 128) == 128)
+			return true;
+		else
+			return false;
+	}
+
+	//Установить 1й бит в номер нумерация с лева на право
+	public static void setBit(byte[] mas, int pos)
+	{
+		int n=(int) Math.floor(pos/8.0);
+		pos=pos - n * 8;
+		
+		mas[n] = (byte)(mas[n] | (128 >> pos)); 
+	}
+	
+	public static String readUTF8_1(InputStream handle) throws IOException
+	{
+		byte[] tmp=new byte[handle.read()];
+		handle.read(tmp);
+		return new String(tmp, "UTF8");
+	}
+	
+	public static float readFloat(DataInputStream InStream) throws IOException
+	{
+		float f;
+		int ch1, ch2, ch3, ch4, count;
+		ch1 = InStream.readUnsignedByte();
+		ch2 = InStream.readUnsignedByte();
+		ch3 = InStream.readUnsignedByte();
+		ch4 = InStream.readUnsignedByte();
+
+		count = (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		f = Float.intBitsToFloat(count);
+		return f;
+	}
+
+	public static int readInt(DataInputStream InStream) throws IOException
+	{
+		int ch1, ch2, ch3, ch4, count;
+		ch1 = InStream.readUnsignedByte();
+		ch2 = InStream.readUnsignedByte();
+		ch3 = InStream.readUnsignedByte();
+		ch4 = InStream.readUnsignedByte();
+
+		count = (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		return count;
+	}
+
+	public static long readUInt(InputStream InStream) throws IOException
+	{
+		long count;
+		int ch1, ch2, ch3, ch4;
+		ch1 = InStream.read();
+		ch2 = InStream.read();
+		ch3 = InStream.read();
+		ch4 = InStream.read();
+
+		count = (ch4 << 24) | (ch3 << 16) | (ch2 << 8) | ch1;
+		return count;
+	}
+
+	//Прочитать 4 байта в unsigned int а так как unsigned нет в java то в long
+	public static long readUInt(byte[] mas,long pos)
+	{
+		byte[] rez = {0, 0, 0, 0, 0, 0, 0, 0};
+		rez[4] = mas[(int)pos+3];
+		rez[5] = mas[(int)pos+2];
+		rez[6] = mas[(int)pos+1];
+		rez[7] = mas[(int)pos+0];
+		long result= ByteBuffer.wrap(rez).getLong();
+		return result;
+	}
+
+	public static short readShort(DataInputStream InStream) throws IOException
+	{
+		int ch1, ch2, count;
+		ch1 = InStream.readUnsignedByte();
+		ch2 = InStream.readUnsignedByte();
+
+		count = (ch2 << 8) | ch1;
+		return (short)count;
+	}
+
+	public static int readUShort(InputStream InStream) throws IOException
+	{
+		int ch1, ch2;
+		ch1 = InStream.read();
+		ch2 = InStream.read();
+		return (ch2 << 8) | ch1;
+	}
+
+	//Записать 4 байта в поток
+	public static void writeInt(OutputStream out, int val) throws IOException
+	{
+		byte[] result = {0, 0, 0, 0};
+		result[0] = (byte) (val >>> 24);
+		result[1] = (byte) (val >>> 16);
+		result[2] = (byte) (val >>> 8);
+		result[3] = (byte) (val >>> 0);
+		out.write(result);
+	}
+
+	//Записать 4 байта в поток
+	public static void writeUInt(OutputStream out, long val) throws IOException
+	{
+		byte[] result = {0, 0, 0, 0};
+		result[0] = (byte) (val >>> 24);
+		result[1] = (byte) (val >>> 16);
+		result[2] = (byte) (val >>> 8);
+		result[3] = (byte) (val >>> 0);
+		out.write(result);
+	}
+
+	public static String afterLast(String str, String ch)
+	{
+		int i=str.lastIndexOf(ch);
+		if(i!=-1)
+		{
+			return str.substring(i+ch.length());
+		}
+		return "";
+    }
+    public static String beforeLast(String str, String ch)
+	{
+		int i=str.lastIndexOf(ch);
+		if(i!=-1)
+		{
+			return str.substring(0,i);
+		}
+		return "";
+    }
+	public static String beforeFirst(String str, String ch)
+	{
+		int i=str.indexOf(ch);
+		if(i!=-1)
+		{
+			return str.substring(0,i);
+		}
+		return "";
+    }
+
+	//узнать точку пересичений 2х линай если x=0 и y=0 то не пересиклась
+	public static Point getCrossingLine(Point PHead0, Point PTail0, Point PHead1, Point PTail1)
+	{
+		Point rezPoint = new Point();
+
+		double a0, b0, c0, a1, b1, c1;
+		boolean bRez = true;
+		a0 = PTail0.y - PHead0.y;
+		b0 = PHead0.x - PTail0.x;
+		c0 = PTail0.x * PHead0.y - PHead0.x * PTail0.y;
+
+		a1 = PTail1.y - PHead1.y;
+		b1 = PHead1.x - PTail1.x;
+		c1 = PTail1.x * PHead1.y - PHead1.x * PTail1.y;
+
+		if (b1 == 0) rezPoint.x = PHead1.x;//если перпендикулярна oy
+		else rezPoint.x = (-(b0 * c1 / b1) + c0) / ((b0 * a1 / b1) - a0);
+		if (a1 == 0) rezPoint.y = PHead1.y;//если перпендикулярна oy
+		else rezPoint.y = (-(c1 * a0 / a1) + c0) / ((a0 * b1 / a1) - b0);
+		//проверка на вхождение в отрезоки (с погрешностью 0.0000001 (зачем понадобилась погрешность?))
+		//по x
+		if ((rezPoint.x < Math.min(PHead0.x, PTail0.x) - 0.0000001) || (rezPoint.x > Math.max(PHead0.x, PTail0.x) + 0.0000001))
+			bRez = false;
+		if ((rezPoint.x < Math.min(PHead1.x, PTail1.x) - 0.0000001) || (rezPoint.x > Math.max(PHead1.x, PTail1.x) + 0.0000001))
+			bRez = false;
+		//по y
+		if ((rezPoint.y < Math.min(PHead0.y, PTail0.y) - 0.0000001) || (rezPoint.y > Math.max(PHead0.y, PTail0.y) + 0.0000001))
+			bRez = false;
+		if ((rezPoint.y < Math.min(PHead1.y, PTail1.y) - 0.0000001) || (rezPoint.y > Math.max(PHead1.y, PTail1.y) + 0.0000001))
+			bRez = false;
+
+		if (!bRez)
+		{
+			rezPoint.x = 0;
+			rezPoint.y = 0;
+		}
+		return rezPoint;
+	}
+
+	public static Point getCrossingLine2(Point PHead0,Point PTail0,Point PHead1,Point PTail1)
+	{
+		boolean bRez=true;
+		Point rezPoint = new Point();
+		rezPoint.x=0;
+		rezPoint.y=0;
+
+		double a0,b0,c0,a1,b1,c1;
+		a0=PTail0.y-PHead0.y;
+		b0=PHead0.x-PTail0.x;
+		c0=PTail0.x*PHead0.y-PHead0.x*PTail0.y;
+
+		a1=PTail1.y-PHead1.y;
+		b1=PHead1.x-PTail1.x;
+		c1=PTail1.x*PHead1.y-PHead1.x*PTail1.y;
+
+		if (b1==0) rezPoint.x=PHead1.x;//если перпендикулярна oy
+		else rezPoint.x=(-(b0*c1/b1)+c0)/((b0*a1/b1)-a0);
+		if (a1==0) rezPoint.y=PHead1.y;//если перпендикулярна ox
+		else rezPoint.y=(-(c1*a0/a1)+c0)/((a0*b1/a1)-b0);
+		//по x
+		if (rezPoint.x<Math.min(PHead0.x,PTail0.x)||rezPoint.x>Math.max(PHead0.x,PTail0.x))
+			bRez=false;
+		if (rezPoint.x<Math.min(PHead1.x,PTail1.x)||rezPoint.x>Math.max(PHead1.x,PTail1.x))
+			bRez=false;
+		//по y
+		if (rezPoint.y<Math.min(PHead0.y,PTail0.y)||rezPoint.y>Math.max(PHead0.y,PTail0.y))
+			bRez=false;
+		if (rezPoint.y<Math.min(PHead1.y,PTail1.y)||rezPoint.y>Math.max(PHead1.y,PTail1.y))
+			bRez=false;
+		if (!bRez)
+		{
+			rezPoint.x=0;
+			rezPoint.y=0;
+		}
+		return rezPoint;
+	}
+
+	//Так как в replaceAll много заморочек с регулярными выражениями
+	public static String replaceAll(String txt, String val, String rep) {
+		if(txt==null || val==null || rep==null) return txt;
+		return txt.replace(val,rep);
+		/*while(true)
+		{
+			String tmpstr=txt.replace(val, rep);
+			if(tmpstr.equals(txt))
+			{
+				txt=tmpstr;
+				break;
+			}else
+			{
+				txt=tmpstr;
+			}
+		}
+		return txt;*/
+	}
+	
+	  public static byte[] subArray(byte[] b, int offset, int length) {
+		    byte[] sub = new byte[length];
+		    for (int i = offset; i < offset + length; i++) {
+		      try {
+		        sub[i - offset] = b[i];
+		      } catch (Exception e) {
+
+		      }
+		    }
+		    return sub;
+	  }
+	//----------------------------------------------------------------------------
+	//ord - менять порядок байт
+	public static long hexStringToInt(String val, boolean ord)
+	{
+		if (ord)
+		{
+			return Long.parseLong(val, 16);
+		}
+		else
+		{
+			String tmp="";
+			for(int i = 0; i < val.length() / 2; i++)
+			{
+				tmp = val.charAt(i * 2 + 1) + tmp;
+				tmp = val.charAt(i * 2) + tmp;
+			}
+			return Long.parseLong(val, 16);
+		}
+	}
+	public static long hexStringToInt(String val)
+	{
+		return hexStringToInt(val,true);
+	}
+	//------------------------------------------------------------------------------
+	//Преобразовать HEX символ в число
+	public static int hexCharToInt(int input)
+	{
+		if(input >= '0' && input <= '9')
+			return input - '0';
+		if(input >= 'A' && input <= 'F')
+			return input - 'A' + 10;
+		if(input >= 'a' && input <= 'f')
+			return input - 'a' + 10;
+		return 0;
+	}
+	//Из руского DOC в юникод
+	public static String fromDOStoASCII(byte[] str)
+	{
+		StringBuilder rez = new StringBuilder();
+		for(int i=0; i <str.length; i++)
+		{
+			switch ((char)str[i])
+			{
+				case (char)0x00: rez.append(0x00); break;
+				case (char)0x01: rez.append(0x01); break;
+				case (char)0x02: rez.append('?'); break;
+				case (char)0x03: rez.append('?'); break;
+				case (char)0x04: rez.append('?'); break;
+				case (char)0x05: rez.append('?'); break;
+				case (char)0x06: rez.append('?'); break;
+				case (char)0x07: rez.append('?'); break;
+				case (char)0x08: rez.append('?'); break;
+				case (char)0x09: rez.append('?'); break;
+				case (char)0x0a: rez.append('?'); break;
+				case (char)0x0b: rez.append('?'); break;
+				case (char)0x0c: rez.append('?'); break;
+				case (char)0x0d: rez.append('?'); break;
+				case (char)0x0e: rez.append('?'); break;
+				case (char)0x0f: rez.append('?'); break;
+
+				case (char)0x10: rez.append('?'); break;
+				case (char)0x11: rez.append('?'); break;
+				case (char)0x12: rez.append('?'); break;
+				case (char)0x13: rez.append('?'); break;
+				case (char)0x14: rez.append('?'); break;
+				case (char)0x15: rez.append('?'); break;
+				case (char)0x16: rez.append('?'); break;
+				case (char)0x17: rez.append('?'); break;
+				case (char)0x18: rez.append('?'); break;
+				case (char)0x19: rez.append('?'); break;
+				case (char)0x1a: rez.append('?'); break;
+				case (char)0x1b: rez.append('?'); break;
+				case (char)0x1c: rez.append('?'); break;
+				case (char)0x1d: rez.append('?'); break;
+				case (char)0x1e: rez.append('?'); break;
+				case (char)0x1f: rez.append('?'); break;
+
+				case (char)0x20: rez.append(' '); break;
+				case (char)0x21: rez.append('!'); break;
+				case (char)0x22: rez.append('"'); break;
+				case (char)0x23: rez.append('#'); break;
+				case (char)0x24: rez.append('$'); break;
+				case (char)0x25: rez.append('%'); break;
+				case (char)0x26: rez.append('&'); break;
+				case (char)0x27: rez.append('\''); break;
+				case (char)0x28: rez.append('('); break;
+				case (char)0x29: rez.append(')'); break;
+				case (char)0x2a: rez.append('*'); break;
+				case (char)0x2b: rez.append('+'); break;
+				case (char)0x2c: rez.append(','); break;
+				case (char)0x2d: rez.append('-'); break;
+				case (char)0x2e: rez.append('.'); break;
+				case (char)0x2f: rez.append('/'); break;
+
+				case (char)0x30: rez.append('0'); break;
+				case (char)0x31: rez.append('1'); break;
+				case (char)0x32: rez.append('2'); break;
+				case (char)0x33: rez.append('3'); break;
+				case (char)0x34: rez.append('4'); break;
+				case (char)0x35: rez.append('5'); break;
+				case (char)0x36: rez.append('6'); break;
+				case (char)0x37: rez.append('7'); break;
+				case (char)0x38: rez.append('8'); break;
+				case (char)0x39: rez.append('9'); break;
+				case (char)0x3a: rez.append(':'); break;
+				case (char)0x3b: rez.append(';'); break;
+				case (char)0x3c: rez.append('<'); break;
+				case (char)0x3d: rez.append('='); break;
+				case (char)0x3e: rez.append('>'); break;
+				case (char)0x3f: rez.append('?'); break;
+
+				case (char)0x40: rez.append('@'); break;
+				case (char)0x41: rez.append('A'); break;
+				case (char)0x42: rez.append('B'); break;
+				case (char)0x43: rez.append('C'); break;
+				case (char)0x44: rez.append('D'); break;
+				case (char)0x45: rez.append('E'); break;
+				case (char)0x46: rez.append('F'); break;
+				case (char)0x47: rez.append('G'); break;
+				case (char)0x48: rez.append('H'); break;
+				case (char)0x49: rez.append('I'); break;
+				case (char)0x4a: rez.append('J'); break;
+				case (char)0x4b: rez.append('K'); break;
+				case (char)0x4c: rez.append('L'); break;
+				case (char)0x4d: rez.append('M'); break;
+				case (char)0x4e: rez.append('N'); break;
+				case (char)0x4f: rez.append('O'); break;
+
+				case (char)0x50: rez.append('P'); break;
+				case (char)0x51: rez.append('Q'); break;
+				case (char)0x52: rez.append('R'); break;
+				case (char)0x53: rez.append('S'); break;
+				case (char)0x54: rez.append('T'); break;
+				case (char)0x55: rez.append('U'); break;
+				case (char)0x56: rez.append('V'); break;
+				case (char)0x57: rez.append('W'); break;
+				case (char)0x58: rez.append('X'); break;
+				case (char)0x59: rez.append('Y'); break;
+				case (char)0x5a: rez.append('Z'); break;
+				case (char)0x5b: rez.append('['); break;
+				case (char)0x5c: rez.append('\\'); break;
+				case (char)0x5d: rez.append(']'); break;
+				case (char)0x5e: rez.append('^'); break;
+				case (char)0x5f: rez.append('_'); break;
+
+				case (char)0x60: rez.append('`'); break;
+				case (char)0x61: rez.append('a'); break;
+				case (char)0x62: rez.append('b'); break;
+				case (char)0x63: rez.append('c'); break;
+				case (char)0x64: rez.append('d'); break;
+				case (char)0x65: rez.append('e'); break;
+				case (char)0x66: rez.append('f'); break;
+				case (char)0x67: rez.append('g'); break;
+				case (char)0x68: rez.append('h'); break;
+				case (char)0x69: rez.append('i'); break;
+				case (char)0x6a: rez.append('j'); break;
+				case (char)0x6b: rez.append('k'); break;
+				case (char)0x6c: rez.append('l'); break;
+				case (char)0x6d: rez.append('m'); break;
+				case (char)0x6e: rez.append('n'); break;
+				case (char)0x6f: rez.append('o'); break;
+
+				case (char)0x70: rez.append('p'); break;
+				case (char)0x71: rez.append('q'); break;
+				case (char)0x72: rez.append('r'); break;
+				case (char)0x73: rez.append('s'); break;
+				case (char)0x74: rez.append('t'); break;
+				case (char)0x75: rez.append('u'); break;
+				case (char)0x76: rez.append('v'); break;
+				case (char)0x77: rez.append('w'); break;
+				case (char)0x78: rez.append('x'); break;
+				case (char)0x79: rez.append('y'); break;
+				case (char)0x7a: rez.append('z'); break;
+				case (char)0x7b: rez.append('{'); break;
+				case (char)0x7c: rez.append('|'); break;
+				case (char)0x7d: rez.append('}'); break;
+				case (char)0x7e: rez.append('~'); break;
+				case (char)0x7f: rez.append((char) 0xf5); break; //х
+
+				case (char)0x80: rez.append((char) 0xc0); break; //А
+				case (char)0x81: rez.append((char) 0xC1); break; //Б
+				case (char)0x82: rez.append((char) 0xC2); break; //В
+				case (char)0x83: rez.append((char) 0xC3); break; //Г
+				case (char)0x84: rez.append((char) 0xC4); break; //Д
+				case (char)0x85: rez.append((char) 0xC5); break; //Е
+				case (char)0x86: rez.append((char) 0xC6); break; //Ж
+				case (char)0x87: rez.append((char) 0xC7); break; //З
+				case (char)0x88: rez.append((char) 0xC8); break; //И
+				case (char)0x89: rez.append((char) 0xC9); break; //Й
+				case (char)0x8a: rez.append((char) 0xCA); break; //К
+				case (char)0x8b: rez.append((char) 0xCB); break; //Л
+				case (char)0x8c: rez.append((char) 0xCC); break; //М
+				case (char)0x8D: rez.append((char) 0xCD); break; //Н
+				case (char)0x8E: rez.append((char) 0xCE); break; //О
+				case (char)0x8f: rez.append((char) 0xCF); break; //П
+
+				case (char)0x90: rez.append((char) 0xD0); break; //Р
+				case (char)0x91: rez.append((char) 0xD1); break; //С
+				case (char)0x92: rez.append((char) 0xD2); break; //Т
+				case (char)0x93: rez.append((char) 0xD3); break; //У
+				case (char)0x94: rez.append((char) 0xD4); break; //Ф
+				case (char)0x95: rez.append((char) 0xD5); break; //Х
+				case (char)0x96: rez.append((char) 0xD6); break; //Ц
+				case (char)0x97: rez.append((char) 0xD7); break; //Ч
+				case (char)0x98: rez.append((char) 0xD8); break; //Ш
+				case (char)0x99: rez.append((char) 0xD9); break; //Щ
+				case (char)0x9a: rez.append((char) 0xDA); break; //Ъ
+				case (char)0x9b: rez.append((char) 0xDB); break; //Ы
+				case (char)0x9c: rez.append((char) 0xDC); break; //Ь
+				case (char)0x9D: rez.append((char) 0xDD); break; //Э
+				case (char)0x9E: rez.append((char) 0xDE); break; //Ю
+				case (char)0x9f: rez.append((char) 0xDF); break; //Я
+
+				case (char)0xa0: rez.append((char) 0xE0); break; //а
+				case (char)0xA1: rez.append((char) 0xE1); break; //б
+				case (char)0xA2: rez.append((char) 0xE2); break; //в
+				case (char)0xA3: rez.append((char) 0xE3); break; //г
+				case (char)0xa4: rez.append((char) 0xE4); break; //д
+				case (char)0xA5: rez.append((char) 0xE5); break; //е
+				case (char)0xa6: rez.append((char) 0xE6); break; //
+				case (char)0xa7: rez.append((char) 0xE7); break; //з
+				case (char)0xa8: rez.append((char) 0xE8); break; //и
+				case (char)0xa9: rez.append((char) 0xE9); break; //й
+				case (char)0xAA: rez.append((char) 0xEA); break; //к
+				case (char)0xab: rez.append((char) 0xEB); break; //л
+				case (char)0xac: rez.append((char) 0xEC); break; //м
+				case (char)0xad: rez.append((char) 0xED); break; //н
+				case (char)0xae: rez.append((char) 0xEE); break; //о
+				case (char)0xAF: rez.append((char) 0xEF); break; //п
+
+				case (char)0xb0: rez.append(' '); break;
+				case (char)0xb1: rez.append(' '); break;
+				case (char)0xb2: rez.append(' '); break;
+				case (char)0xb3: rez.append(' '); break;
+				case (char)0xB4: rez.append(' '); break;
+				case (char)0xb5: rez.append(' '); break;
+				case (char)0xb6: rez.append(' '); break;
+				case (char)0xb7: rez.append(' '); break;
+				case (char)0xb8: rez.append(' '); break;
+				case (char)0xb9: rez.append(' '); break;
+				case (char)0xBA: rez.append(' '); break;
+				case (char)0xbb: rez.append(' '); break;
+				case (char)0xBC: rez.append(' '); break;
+				case (char)0xBD: rez.append(' '); break;
+				case (char)0xBE: rez.append(' '); break;
+				case (char)0xBF: rez.append(' '); break;
+
+				case (char)0xc0: rez.append(' '); break;
+				case (char)0xc1: rez.append(' '); break;
+				case (char)0xc2: rez.append(' '); break;
+				case (char)0xc3: rez.append(' '); break;
+				case (char)0xc4: rez.append(' '); break;
+				case (char)0xc5: rez.append(' '); break;
+				case (char)0xc6: rez.append(' '); break;
+				case (char)0xc7: rez.append(' '); break;
+				case (char)0xc8: rez.append(' '); break;
+				case (char)0xc9: rez.append(' '); break;
+				case (char)0xca: rez.append(' '); break;
+				case (char)0xcb: rez.append(' '); break;
+				case (char)0xcc: rez.append(' '); break;
+				case (char)0xcd: rez.append(' '); break;
+				case (char)0xce: rez.append(' '); break;
+				case (char)0xcf: rez.append(' '); break;
+
+				case (char)0xd0: rez.append(' '); break;
+				case (char)0xd1: rez.append(' '); break;
+				case (char)0xd2: rez.append(' '); break;
+				case (char)0xd3: rez.append(' '); break;
+				case (char)0xd4: rez.append(' '); break;
+				case (char)0xd5: rez.append(' '); break;
+				case (char)0xd6: rez.append(' '); break;
+				case (char)0xd7: rez.append(' '); break;
+				case (char)0xd8: rez.append(' '); break;
+				case (char)0xd9: rez.append(' '); break;
+				case (char)0xda: rez.append(' '); break;
+				case (char)0xdb: rez.append(' '); break;
+				case (char)0xdc: rez.append(' '); break;
+				case (char)0xdd: rez.append(' '); break;
+				case (char)0xde: rez.append(' '); break;
+				case (char)0xdf: rez.append(' '); break;
+
+				case (char)0xe0: rez.append((char) 0xF0); break; //р
+				case (char)0xe1: rez.append((char) 0xF1); break; //с
+				case (char)0xe2: rez.append((char) 0xF2); break; //т
+				case (char)0xe3: rez.append((char) 0xF3); break; //у
+				case (char)0xe4: rez.append((char) 0xF4); break; //ф
+				case (char)0xe5: rez.append((char) 0xF5); break; //х
+				case (char)0xe6: rez.append((char) 0xF6); break; //ц
+				case (char)0xe7: rez.append((char) 0xF7); break; //ч
+				case (char)0xe8: rez.append((char) 0xF8); break; //ш
+				case (char)0xe9: rez.append((char) 0xF9); break; //щ
+				case (char)0xea: rez.append((char) 0xFA); break; //ъ
+				case (char)0xeb: rez.append((char) 0xFB); break; //ы
+				case (char)0xec: rez.append((char) 0xFC); break; //ь
+				case (char)0xed: rez.append((char) 0xFD); break; //э
+				case (char)0xee: rez.append((char) 0xFE); break; //ю
+				case (char)0xef: rez.append((char) 0xFF); break; //я
+
+				case (char)0xf0: rez.append(' '); break;
+				case (char)0xf1: rez.append(' '); break;
+				case (char)0xf2: rez.append(' '); break;
+				case (char)0xf3: rez.append(' '); break;
+				case (char)0xf4: rez.append(' '); break;
+				case (char)0xf5: rez.append(' '); break;
+				case (char)0xf6: rez.append(' '); break;
+				case (char)0xf7: rez.append(' '); break;
+				case (char)0xf8: rez.append(' '); break;
+				case (char)0xf9: rez.append(' '); break;
+				case (char)0xfa: rez.append(' '); break;
+				case (char)0xfb: rez.append(' '); break;
+				case (char)0xfc: rez.append(' '); break;
+				case (char)0xfd: rez.append(' '); break;
+				case (char)0xfe: rez.append(' '); break;
+				case (char)0xff: rez.append(' '); break;
+				default:
+					rez.append('?');
+			}
+		}
+		return rez.toString();
+	}
+
+	public static byte[] fromASCIItoDOS(String str)
+	{
+		byte[] rez = new byte[str.length()];
+		for(int i=0;i<str.length();i++)
+		{
+			switch (str.charAt(i))
+			{
+				case (char)0x00: rez[i]=(byte)0x00; break;
+				case (char)0x01: rez[i]=(byte)0x01; break;
+				case (char)0x02: rez[i]=(byte)'?'; break;
+				case (char)0x03: rez[i]=(byte)'?'; break;
+				case (char)0x04: rez[i]=(byte)'?'; break;
+				case (char)0x05: rez[i]=(byte)'?'; break;
+				case (char)0x06: rez[i]=(byte)'?'; break;
+				case (char)0x07: rez[i]=(byte)'?'; break;
+				case (char)0x08: rez[i]=(byte)'?'; break;
+				case (char)0x09: rez[i]=(byte)'?'; break;
+				case (char)0x0a: rez[i]=(byte)'?'; break;
+				case (char)0x0b: rez[i]=(byte)'?'; break;
+				case (char)0x0c: rez[i]=(byte)'?'; break;
+				case (char)0x0d: rez[i]=(byte)'?'; break;
+				case (char)0x0e: rez[i]=(byte)'?'; break;
+				case (char)0x0f: rez[i]=(byte)'?'; break;
+
+				case (char)0x10: rez[i]=(byte)'?'; break;
+				case (char)0x11: rez[i]=(byte)'?'; break;
+				case (char)0x12: rez[i]=(byte)'?'; break;
+				case (char)0x13: rez[i]=(byte)'?'; break;
+				case (char)0x14: rez[i]=(byte)'?'; break;
+				case (char)0x15: rez[i]=(byte)'?'; break;
+				case (char)0x16: rez[i]=(byte)'?'; break;
+				case (char)0x17: rez[i]=(byte)'?'; break;
+				case (char)0x18: rez[i]=(byte)'?'; break;
+				case (char)0x19: rez[i]=(byte)'?'; break;
+				case (char)0x1a: rez[i]=(byte)'?'; break;
+				case (char)0x1b: rez[i]=(byte)'?'; break;
+				case (char)0x1c: rez[i]=(byte)'?'; break;
+				case (char)0x1d: rez[i]=(byte)'?'; break;
+				case (char)0x1e: rez[i]=(byte)'?'; break;
+				case (char)0x1f: rez[i]=(byte)'?'; break;
+
+				case (char)0x20: rez[i]=(byte)' '; break;
+				case (char)0x21: rez[i]=(byte)'!'; break;
+				case (char)0x22: rez[i]=(byte)'"'; break;
+				case (char)0x23: rez[i]=(byte)'#'; break;
+				case (char)0x24: rez[i]=(byte)'$'; break;
+				case (char)0x25: rez[i]=(byte)'%'; break;
+				case (char)0x26: rez[i]=(byte)'&'; break;
+				case (char)0x27: rez[i]=(byte)'\''; break;
+				case (char)0x28: rez[i]=(byte)'('; break;
+				case (char)0x29: rez[i]=(byte)')'; break;
+				case (char)0x2a: rez[i]=(byte)'*'; break;
+				case (char)0x2b: rez[i]=(byte)'+'; break;
+				case (char)0x2c: rez[i]=(byte)','; break;
+				case (char)0x2d: rez[i]=(byte)'-'; break;
+				case (char)0x2e: rez[i]=(byte)'.'; break;
+				case (char)0x2f: rez[i]=(byte)'/'; break;
+
+				case (char)0x30: rez[i]=(byte)'0'; break;
+				case (char)0x31: rez[i]=(byte)'1'; break;
+				case (char)0x32: rez[i]=(byte)'2'; break;
+				case (char)0x33: rez[i]=(byte)'3'; break;
+				case (char)0x34: rez[i]=(byte)'4'; break;
+				case (char)0x35: rez[i]=(byte)'5'; break;
+				case (char)0x36: rez[i]=(byte)'6'; break;
+				case (char)0x37: rez[i]=(byte)'7'; break;
+				case (char)0x38: rez[i]=(byte)'8'; break;
+				case (char)0x39: rez[i]=(byte)'9'; break;
+				case (char)0x3a: rez[i]=(byte)':'; break;
+				case (char)0x3b: rez[i]=(byte)';'; break;
+				case (char)0x3c: rez[i]=(byte)'<'; break;
+				case (char)0x3d: rez[i]=(byte)'='; break;
+				case (char)0x3e: rez[i]=(byte)'>'; break;
+				case (char)0x3f: rez[i]=(byte)'?'; break;
+
+				case (char)0x40: rez[i]=(byte)'@'; break;
+				case (char)0x41: rez[i]=(byte)'A'; break;
+				case (char)0x42: rez[i]=(byte)'B'; break;
+				case (char)0x43: rez[i]=(byte)'C'; break;
+				case (char)0x44: rez[i]=(byte)'D'; break;
+				case (char)0x45: rez[i]=(byte)'E'; break;
+				case (char)0x46: rez[i]=(byte)'F'; break;
+				case (char)0x47: rez[i]=(byte)'G'; break;
+				case (char)0x48: rez[i]=(byte)'H'; break;
+				case (char)0x49: rez[i]=(byte)'I'; break;
+				case (char)0x4a: rez[i]=(byte)'J'; break;
+				case (char)0x4b: rez[i]=(byte)'K'; break;
+				case (char)0x4c: rez[i]=(byte)'L'; break;
+				case (char)0x4d: rez[i]=(byte)'M'; break;
+				case (char)0x4e: rez[i]=(byte)'N'; break;
+				case (char)0x4f: rez[i]=(byte)'O'; break;
+
+				case (char)0x50: rez[i]=(byte)'P'; break;
+				case (char)0x51: rez[i]=(byte)'Q'; break;
+				case (char)0x52: rez[i]=(byte)'R'; break;
+				case (char)0x53: rez[i]=(byte)'S'; break;
+				case (char)0x54: rez[i]=(byte)'T'; break;
+				case (char)0x55: rez[i]=(byte)'U'; break;
+				case (char)0x56: rez[i]=(byte)'V'; break;
+				case (char)0x57: rez[i]=(byte)'W'; break;
+				case (char)0x58: rez[i]=(byte)'X'; break;
+				case (char)0x59: rez[i]=(byte)'Y'; break;
+				case (char)0x5a: rez[i]=(byte)'Z'; break;
+				case (char)0x5b: rez[i]=(byte)'['; break;
+				case (char)0x5c: rez[i]=(byte)'\\'; break;
+				case (char)0x5d: rez[i]=(byte)']'; break;
+				case (char)0x5e: rez[i]=(byte)'^'; break;
+				case (char)0x5f: rez[i]=(byte)'_'; break;
+
+				case (char)0x60: rez[i]=(byte)'`'; break;
+				case (char)0x61: rez[i]=(byte)'a'; break;
+				case (char)0x62: rez[i]=(byte)'b'; break;
+				case (char)0x63: rez[i]=(byte)'c'; break;
+				case (char)0x64: rez[i]=(byte)'d'; break;
+				case (char)0x65: rez[i]=(byte)'e'; break;
+				case (char)0x66: rez[i]=(byte)'f'; break;
+				case (char)0x67: rez[i]=(byte)'g'; break;
+				case (char)0x68: rez[i]=(byte)'h'; break;
+				case (char)0x69: rez[i]=(byte)'i'; break;
+				case (char)0x6a: rez[i]=(byte)'j'; break;
+				case (char)0x6b: rez[i]=(byte)'k'; break;
+				case (char)0x6c: rez[i]=(byte)'l'; break;
+				case (char)0x6d: rez[i]=(byte)'m'; break;
+				case (char)0x6e: rez[i]=(byte)'n'; break;
+				case (char)0x6f: rez[i]=(byte)'o'; break;
+
+				case (char)0x70: rez[i]=(byte)'p'; break;
+				case (char)0x71: rez[i]=(byte)'q'; break;
+				case (char)0x72: rez[i]=(byte)'r'; break;
+				case (char)0x73: rez[i]=(byte)'s'; break;
+				case (char)0x74: rez[i]=(byte)'t'; break;
+				case (char)0x75: rez[i]=(byte)'u'; break;
+				case (char)0x76: rez[i]=(byte)'v'; break;
+				case (char)0x77: rez[i]=(byte)'w'; break;
+				case (char)0x78: rez[i]=(byte)'x'; break;
+				case (char)0x79: rez[i]=(byte)'y'; break;
+				case (char)0x7a: rez[i]=(byte)'z'; break;
+				case (char)0x7b: rez[i]=(byte)'{'; break;
+				case (char)0x7c: rez[i]=(byte)'|'; break;
+				case (char)0x7d: rez[i]=(byte)'}'; break;
+				case (char)0x7e: rez[i]=(byte)'~'; break;
+				case (char)0x7f: rez[i]=(byte)'×'; break; //127
+
+				case (char)0x80: rez[i]=(byte)' '; break; //128
+				case (char)0x81: rez[i]=(byte)' '; break;
+				case (char)0x82: rez[i]=(byte)' '; break;
+				case (char)0x83: rez[i]=(byte)' '; break;
+				case (char)0x84: rez[i]=(byte)' '; break;
+				case (char)0x85: rez[i]=(byte)' '; break;
+				case (char)0x86: rez[i]=(byte)' '; break;
+				case (char)0x87: rez[i]=(byte)' '; break;
+				case (char)0x88: rez[i]=(byte)' '; break;
+				case (char)0x89: rez[i]=(byte)' '; break;
+				case (char)0x8a: rez[i]=(byte)' '; break;
+				case (char)0x8b: rez[i]=(byte)' '; break;
+				case (char)0x8c: rez[i]=(byte)' '; break;
+				case (char)0x8D: rez[i]=(byte)' '; break;
+				case (char)0x8E: rez[i]=(byte)' '; break;
+				case (char)0x8f: rez[i]=(byte)' '; break;
+
+				case (char)0x90: rez[i]=(byte)' '; break;
+				case (char)0x91: rez[i]=(byte)' '; break;
+				case (char)0x92: rez[i]=(byte)' '; break;
+				case (char)0x93: rez[i]=(byte)' '; break;
+				case (char)0x94: rez[i]=(byte)' '; break;
+				case (char)0x95: rez[i]=(byte)' '; break;
+				case (char)0x96: rez[i]=(byte)' '; break;
+				case (char)0x97: rez[i]=(byte)' '; break;
+				case (char)0x98: rez[i]=(byte)' '; break;
+				case (char)0x99: rez[i]=(byte)' '; break;
+				case (char)0x9a: rez[i]=(byte)' '; break;
+				case (char)0x9b: rez[i]=(byte)' '; break;
+				case (char)0x9c: rez[i]=(byte)' '; break;
+				case (char)0x9D: rez[i]=(byte)' '; break;
+				case (char)0x9E: rez[i]=(byte)' '; break;
+				case (char)0x9f: rez[i]=(byte)' '; break;
+
+				case (char)0xa0: rez[i]=(byte)' '; break;
+				case (char)0xA1: rez[i]=(byte)' '; break;
+				case (char)0xA2: rez[i]=(byte)' '; break;
+				case (char)0xA3: rez[i]=(byte)' '; break;
+				case (char)0xa4: rez[i]=(byte)' '; break;
+				case (char)0xA5: rez[i]=(byte)' '; break;
+				case (char)0xa6: rez[i]=(byte)' '; break;
+				case (char)0xa7: rez[i]=(byte)' '; break;
+				case (char)0xa8: rez[i]=(byte)' '; break;
+				case (char)0xa9: rez[i]=(byte)' '; break;
+				case (char)0xAA: rez[i]=(byte)' '; break;
+				case (char)0xab: rez[i]=(byte)' '; break;
+				case (char)0xac: rez[i]=(byte)' '; break;
+				case (char)0xad: rez[i]=(byte)' '; break;
+				case (char)0xae: rez[i]=(byte)' '; break;
+				case (char)0xAF: rez[i]=(byte)' '; break;
+
+				case (char)0xb0: rez[i]=(byte)' '; break;
+				case (char)0xb1: rez[i]=(byte)' '; break;
+				case (char)0xb2: rez[i]=(byte)' '; break;
+				case (char)0xb3: rez[i]=(byte)' '; break;
+				case (char)0xB4: rez[i]=(byte)' '; break;
+				case (char)0xb5: rez[i]=(byte)' '; break;
+				case (char)0xb6: rez[i]=(byte)' '; break;
+				case (char)0xb7: rez[i]=(byte)' '; break;
+				case (char)0xb8: rez[i]=(byte)' '; break;
+				case (char)0xb9: rez[i]=(byte)' '; break;
+				case (char)0xBA: rez[i]=(byte)' '; break;
+				case (char)0xbb: rez[i]=(byte)' '; break;
+				case (char)0xBC: rez[i]=(byte)' '; break;
+				case (char)0xBD: rez[i]=(byte)' '; break;
+				case (char)0xBE: rez[i]=(byte)' '; break;
+				case (char)0xBF: rez[i]=(byte)' '; break;
+
+				case (char)0xc0: rez[i]=(byte)0x80; break;
+				case (char)0xc1: rez[i]=(byte)0x81; break;
+				case (char)0xc2: rez[i]=(byte)0x82; break;
+				case (char)0xc3: rez[i]=(byte)0x83; break;
+				case (char)0xc4: rez[i]=(byte)0x84; break;
+				case (char)0xc5: rez[i]=(byte)0x85; break;
+				case (char)0xc6: rez[i]=(byte)0x86; break;
+				case (char)0xc7: rez[i]=(byte)0x87; break;
+				case (char)0xc8: rez[i]=(byte)0x88; break;
+				case (char)0xc9: rez[i]=(byte)0x89; break;
+				case (char)0xca: rez[i]=(byte)0x8a; break;
+				case (char)0xcb: rez[i]=(byte)0x8b; break;
+				case (char)0xcc: rez[i]=(byte)0x8c; break;
+				case (char)0xcd: rez[i]=(byte)0x8d; break;
+				case (char)0xce: rez[i]=(byte)0x8e; break;
+				case (char)0xcf: rez[i]=(byte)0x8f; break;
+
+				case (char)0xd0: rez[i]=(byte)0x90; break;
+				case (char)0xd1: rez[i]=(byte)0x91; break;
+				case (char)0xd2: rez[i]=(byte)0x92; break;
+				case (char)0xd3: rez[i]=(byte)0x93; break;
+				case (char)0xd4: rez[i]=(byte)0x94; break;
+				case (char)0xd5: rez[i]=(byte)0x95; break;
+				case (char)0xd6: rez[i]=(byte)0x96; break;
+				case (char)0xd7: rez[i]=(byte)0x97; break;
+				case (char)0xd8: rez[i]=(byte)0x98; break;
+				case (char)0xd9: rez[i]=(byte)0x99; break;
+				case (char)0xda: rez[i]=(byte)0x9a; break;
+				case (char)0xdb: rez[i]=(byte)0x9b; break;
+				case (char)0xdc: rez[i]=(byte)0x9c; break;
+				case (char)0xdd: rez[i]=(byte)0x9d; break;
+				case (char)0xde: rez[i]=(byte)0x9e; break;
+				case (char)0xdf: rez[i]=(byte)0x9f; break;
+
+				case (char)0xe0: rez[i]=(byte)0xa0; break;
+				case (char)0xe1: rez[i]=(byte)0xa1; break;
+				case (char)0xe2: rez[i]=(byte)0xa2; break;
+				case (char)0xe3: rez[i]=(byte)0xa3; break;
+				case (char)0xe4: rez[i]=(byte)0xa4; break;
+				case (char)0xe5: rez[i]=(byte)0xa5; break;
+				case (char)0xe6: rez[i]=(byte)0xa6; break;
+				case (char)0xe7: rez[i]=(byte)0xa7; break;
+				case (char)0xe8: rez[i]=(byte)0xa8; break;
+				case (char)0xe9: rez[i]=(byte)0xa9; break;
+				case (char)0xea: rez[i]=(byte)0xaa; break;
+				case (char)0xeb: rez[i]=(byte)0xab; break;
+				case (char)0xec: rez[i]=(byte)0xac; break;
+				case (char)0xed: rez[i]=(byte)0xad; break;
+				case (char)0xee: rez[i]=(byte)0xae; break;
+				case (char)0xef: rez[i]=(byte)0xaf; break;
+
+				case (char)0xf0: rez[i]=(byte)0xe0; break;
+				case (char)0xf1: rez[i]=(byte)0xe1; break;
+				case (char)0xf2: rez[i]=(byte)0xe2; break;
+				case (char)0xf3: rez[i]=(byte)0xe3; break;
+				case (char)0xf4: rez[i]=(byte)0xe4; break;
+				case (char)0xf5: rez[i]=(byte)0xe5; break;
+				case (char)0xf6: rez[i]=(byte)0xe6; break;
+				case (char)0xf7: rez[i]=(byte)0xe7; break;
+				case (char)0xf8: rez[i]=(byte)0xe8; break;
+				case (char)0xf9: rez[i]=(byte)0xe9; break;
+				case (char)0xfa: rez[i]=(byte)0xea; break;
+				case (char)0xfb: rez[i]=(byte)0xeb; break;
+				case (char)0xfc: rez[i]=(byte)0xec; break;
+				case (char)0xfd: rez[i]=(byte)0xed; break;
+				case (char)0xfe: rez[i]=(byte)0xee; break;
+				case (char)0xff: rez[i]=(byte)0xef; break;
+				default:
+					rez[i]='?';
+			}
+		}
+		return rez;
+	}
+	//---------------------------------------------------------------------------
+	public static final String md5(final String str)
+	{
+		try {
+			// Create MD5 Hash
+			MessageDigest digest = MessageDigest
+					.getInstance("MD5");
+			digest.update(str.getBytes());
+			byte messageDigest[] = digest.digest();
+
+			// Create Hex String
+			StringBuffer hexString = new StringBuffer();
+			for (int i = 0; i < messageDigest.length; i++) {
+				StringBuilder h = new StringBuilder(Integer.toHexString(0xFF & messageDigest[i]));
+				while (h.length() < 2)
+					h.insert(0, "0");
+				hexString.append(h);
+			}
+			return hexString.toString();
+
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		}
+		return "";
+	}
+	//---------------------------------------------------------------------------
+	//Отрезать от строки до указанного символа если не найден символ отрезается вся строка
+	public static String CutBeforeFirst(StringBuffer str, String ch)
+	{
+		int pos=str.indexOf(ch);
+		String result="";
+		if(pos==-1)
+		{
+			result.concat(str.toString());
+			str.delete(0,str.length());
+		}else
+		{
+			result=str.substring(0,pos);
+			str.delete(0,pos+1);
+		}
+		return result;
+	}
+	//---------------------------------------------------------------------------
+	public static int StdStrToInt(String str, boolean cutInt)
+	{
+		if(cutInt)
+		{
+			StringBuilder val= new StringBuilder();
+			for(int i=0;i<str.length();i++)
+			{
+				if((str.charAt(i)=='-' && (val.length()==0 || val.charAt(0)!='-'))  || str.charAt(i)=='0' || str.charAt(i)=='1' || str.charAt(i)=='2' || str.charAt(i)=='3' || str.charAt(i)=='4' || str.charAt(i)=='5' || str.charAt(i)=='6' || str.charAt(i)=='7' || str.charAt(i)=='8' || str.charAt(i)=='9')
+					val.append(str.charAt(i));
+			}
+			if(val.toString().equals("")) return 0;
+			return Integer.parseInt(val.toString());
+		}
+		if(str.equals("")) return 0;
+		return Integer.parseInt(str);
+	}
+	//---------------------------------------------------------------------------
+	//Вернёт значение бита на заданной позиции
+	//pos - Позиция 7..0
+	public static boolean getBitVal(int val,int pos)
+	{
+		int v=val;
+		v=v<<pos;
+		return (val & v) == v;
+	}
+	//---------------------------------------------------------------------------
+	//Из казахского ASCII в юникод см: http://foxtools.ru/ASCII#1251
+	public static String fromKAZASCII(byte[] str)
+	{
+		StringBuilder rez = new StringBuilder();
+		for (int i = 0; i < str.length; i++)
+		{
+			switch ((char) str[i])
+			{
+				case 0x00:
+					rez.append(0x00);
+					break;
+				case 0x01:
+					rez.append(0x01);
+					break;
+				case 0x02:
+				case 0x03:
+					rez.append('?');
+					break;
+				case 0x04:
+					rez.append('?');
+					break;
+				case 0x05:
+					rez.append('?');
+					break;
+				case 0x06:
+					rez.append('?');
+					break;
+				case 0x07:
+					rez.append('?');
+					break;
+				case 0x08:
+					rez.append('?');
+					break;
+				case 0x09:
+					rez.append('\t');
+					break;
+				case 0x0a:
+					rez.append('?');
+					break;
+				case 0x0b:
+					rez.append('?');
+					break;
+				case 0x0c:
+					rez.append('?');
+					break;
+				case 0x0d:
+					rez.append('?');
+					break;
+				case 0x0e:
+					rez.append('?');
+					break;
+				case 0x0f:
+					rez.append('?');
+					break;
+
+				case 0x10:
+					rez.append('?');
+					break;
+				case 0x11:
+					rez.append('?');
+					break;
+				case 0x12:
+					rez.append('?');
+					break;
+				case 0x13:
+					rez.append('?');
+					break;
+				case 0x14:
+					rez.append('?');
+					break;
+				case 0x15:
+					rez.append('?');
+					break;
+				case 0x16:
+					rez.append('?');
+					break;
+				case 0x17:
+					rez.append('?');
+					break;
+				case 0x18:
+					rez.append('?');
+					break;
+				case 0x19:
+					rez.append('?');
+					break;
+				case 0x1a:
+					rez.append('?');
+					break;
+				case 0x1b:
+					rez.append('?');
+					break;
+				case 0x1c:
+					rez.append('?');
+					break;
+				case 0x1d:
+					rez.append('?');
+					break;
+				case 0x1e:
+					rez.append('?');
+					break;
+				case 0x1f:
+					rez.append('?');
+					break;
+
+				case 0x20:
+					rez.append(' ');
+					break;
+				case 0x21:
+					rez.append('!');
+					break;
+				case 0x22:
+					rez.append('"');
+					break;
+				case 0x23:
+					rez.append('#');
+					break;
+				case 0x24:
+					rez.append('$');
+					break;
+				case 0x25:
+					rez.append('%');
+					break;
+				case 0x26:
+					rez.append('&');
+					break;
+				case 0x27:
+					rez.append('\'');
+					break;
+				case 0x28:
+					rez.append('(');
+					break;
+				case 0x29:
+					rez.append(')');
+					break;
+				case 0x2a:
+					rez.append('*');
+					break;
+				case 0x2b:
+					rez.append('+');
+					break;
+				case 0x2c:
+					rez.append(',');
+					break;
+				case 0x2d:
+					rez.append('-');
+					break;
+				case 0x2e:
+					rez.append('.');
+					break;
+				case 0x2f:
+					rez.append('/');
+					break;
+
+				case 0x30:
+					rez.append('0');
+					break;
+				case 0x31:
+					rez.append('1');
+					break;
+				case 0x32:
+					rez.append('2');
+					break;
+				case 0x33:
+					rez.append('3');
+					break;
+				case 0x34:
+					rez.append('4');
+					break;
+				case 0x35:
+					rez.append('5');
+					break;
+				case 0x36:
+					rez.append('6');
+					break;
+				case 0x37:
+					rez.append('7');
+					break;
+				case 0x38:
+					rez.append('8');
+					break;
+				case 0x39:
+					rez.append('9');
+					break;
+				case 0x3a:
+					rez.append(':');
+					break;
+				case 0x3b:
+					rez.append(';');
+					break;
+				case 0x3c:
+					rez.append('<');
+					break;
+				case 0x3d:
+					rez.append('=');
+					break;
+				case 0x3e:
+					rez.append('>');
+					break;
+				case 0x3f:
+					rez.append('?');
+					break;
+
+				case 0x40:
+					rez.append('@');
+					break;
+				case 0x41:
+					rez.append('A');
+					break;
+				case 0x42:
+					rez.append('B');
+					break;
+				case 0x43:
+					rez.append('C');
+					break;
+				case 0x44:
+					rez.append('D');
+					break;
+				case 0x45:
+					rez.append('E');
+					break;
+				case 0x46:
+					rez.append('F');
+					break;
+				case 0x47:
+					rez.append('G');
+					break;
+				case 0x48:
+					rez.append('H');
+					break;
+				case 0x49:
+					rez.append('I');
+					break;
+				case 0x4a:
+					rez.append('J');
+					break;
+				case 0x4b:
+					rez.append('K');
+					break;
+				case 0x4c:
+					rez.append('L');
+					break;
+				case 0x4d:
+					rez.append('M');
+					break;
+				case 0x4e:
+					rez.append('N');
+					break;
+				case 0x4f:
+					rez.append('O');
+					break;
+
+				case 0x50:
+					rez.append('P');
+					break;
+				case 0x51:
+					rez.append('Q');
+					break;
+				case 0x52:
+					rez.append('R');
+					break;
+				case 0x53:
+					rez.append('S');
+					break;
+				case 0x54:
+					rez.append('T');
+					break;
+				case 0x55:
+					rez.append('U');
+					break;
+				case 0x56:
+					rez.append('V');
+					break;
+				case 0x57:
+					rez.append('W');
+					break;
+				case 0x58:
+					rez.append('X');
+					break;
+				case 0x59:
+					rez.append('Y');
+					break;
+				case 0x5a:
+					rez.append('Z');
+					break;
+				case 0x5b:
+					rez.append('[');
+					break;
+				case 0x5c:
+					rez.append('\\');
+					break;
+				case 0x5d:
+					rez.append(']');
+					break;
+				case 0x5e:
+					rez.append('^');
+					break;
+				case 0x5f:
+					rez.append('_');
+					break;
+
+				case 0x60:
+					rez.append('`');
+					break;
+				case 0x61:
+					rez.append('a');
+					break;
+				case 0x62:
+					rez.append('b');
+					break;
+				case 0x63:
+					rez.append('c');
+					break;
+				case 0x64:
+					rez.append('d');
+					break;
+				case 0x65:
+					rez.append('e');
+					break;
+				case 0x66:
+					rez.append('f');
+					break;
+				case 0x67:
+					rez.append('g');
+					break;
+				case 0x68:
+					rez.append('h');
+					break;
+				case 0x69:
+					rez.append('i');
+					break;
+				case 0x6a:
+					rez.append('j');
+					break;
+				case 0x6b:
+					rez.append('k');
+					break;
+				case 0x6c:
+					rez.append('l');
+					break;
+				case 0x6d:
+					rez.append('m');
+					break;
+				case 0x6e:
+					rez.append('n');
+					break;
+				case 0x6f:
+					rez.append('o');
+					break;
+
+				case 0x70:
+					rez.append('p');
+					break;
+				case 0x71:
+					rez.append('q');
+					break;
+				case 0x72:
+					rez.append('r');
+					break;
+				case 0x73:
+					rez.append('s');
+					break;
+				case 0x74:
+					rez.append('t');
+					break;
+				case 0x75:
+					rez.append('u');
+					break;
+				case 0x76:
+					rez.append('v');
+					break;
+				case 0x77:
+					rez.append('w');
+					break;
+				case 0x78:
+					rez.append('x');
+					break;
+				case 0x79:
+					rez.append('y');
+					break;
+				case 0x7a:
+					rez.append('z');
+					break;
+				case 0x7b:
+					rez.append('{');
+					break;
+				case 0x7c:
+					rez.append('|');
+					break;
+				case 0x7d:
+					rez.append('}');
+					break;
+				case 0x7e:
+					rez.append('~');
+					break;
+				case 0x7f:
+					rez.append('×');
+					break; //127
+
+				case 0x80:
+					rez.append(' ');
+					break;
+				case 0x81:
+					rez.append('Ғ');
+					break;
+				case 0x82:
+					rez.append(' ');
+					break;
+				case 0x83:
+					rez.append('ғ');
+					break;
+				case 0x84:
+					rez.append(' ');
+					break;
+				case 0x85:
+					rez.append(' ');
+					break;
+				case 0x86:
+					rez.append(' ');
+					break;
+				case 0x87:
+					rez.append(' ');
+					break;
+				case 0x88:
+					rez.append(' ');
+					break;
+				case 0x89:
+					rez.append('№');
+					break;
+				case 0x8a:
+					rez.append('Ә');
+					break;
+				case 0x8b:
+					rez.append(' ');
+					break;
+				case 0x8c:
+					rez.append('Ң');
+					break;
+				case 0x8D:
+					rez.append('Қ');
+					break;
+				case 0x8E:
+					rez.append('Һ');
+					break;
+				case 0x8f:
+					rez.append(' ');
+					break;
+
+				case 0x90:
+					rez.append(' ');
+					break;
+				case 0x91:
+					rez.append(' ');
+					break;
+				case 0x92:
+					rez.append(' ');
+					break;
+				case 0x93:
+					rez.append(' ');
+					break;
+				case 0x94:
+					rez.append(' ');
+					break;
+				case 0x95:
+					rez.append(' ');
+					break;
+				case 0x96:
+					rez.append(' ');
+					break;
+				case 0x97:
+					rez.append(' ');
+					break;
+				case 0x98:
+					rez.append(' ');
+					break;
+				case 0x99:
+					rez.append(' ');
+					break;
+				case 0x9a:
+					rez.append('ә');
+					break;
+				case 0x9b:
+					rez.append(' ');
+					break;
+				case 0x9c:
+					rez.append('ң');
+					break;
+				case 0x9D:
+					rez.append('қ');
+					break;
+				case 0x9E:
+					rez.append('һ');
+					break;
+				case 0x9f:
+					rez.append(' ');
+					break;
+				case 0xa0:
+					rez.append(' ');
+					break;
+				case 0xA1:
+					rez.append('Ұ');
+					break;
+				case 0xA2:
+					rez.append('ұ');
+					break;
+				case 0xA3:
+					rez.append(' ');
+					break;
+				case 0xa4:
+					rez.append(' ');
+					break;
+				case 0xA5:
+					rez.append(' ');
+					break;
+				case 0xa6:
+					rez.append(' ');
+					break;
+				case 0xa7:
+					rez.append(' ');
+					break;
+				case 0xa8:
+					rez.append('Ё');
+					break;
+				case 0xa9:
+					rez.append(' ');
+					break;
+				case 0xAA:
+					rez.append('Ө');
+					break;
+				case 0xab:
+					rez.append(' ');
+					break;
+				case 0xac:
+					rez.append(' ');
+					break;
+				case 0xad:
+					rez.append(' ');
+					break;
+				case 0xae:
+					rez.append(' ');
+					break;
+				case 0xAF:
+					rez.append('Ү');
+					break;
+
+				case 0xb0:
+					rez.append(' ');
+					break;
+				case 0xb1:
+					rez.append(' ');
+					break;
+				case 0xb2:
+					rez.append('І');
+					break;
+				case 0xb3:
+					rez.append('і');
+					break;
+				case 0xB4:
+					rez.append(' ');
+					break;
+				case 0xb5:
+					rez.append(' ');
+					break;
+				case 0xb6:
+					rez.append(' ');
+					break;
+				case 0xb7:
+					rez.append(' ');
+					break;
+				case 0xb8:
+					rez.append('ё');
+					break;
+				case 0xb9:
+					rez.append(' ');
+					break;
+				case 0xBA:
+					rez.append('ө');
+					break;
+				case 0xbb:
+					rez.append(' ');
+					break;
+				case 0xBC:
+					rez.append(' ');
+					break;
+				case 0xBD:
+					rez.append(' ');
+					break;
+				case 0xBE:
+					rez.append(' ');
+					break;
+				case 0xBF:
+					rez.append('ү');
+					break;
+
+				case 0xc0:
+					rez.append('А');
+					break;
+				case 0xc1:
+					rez.append('Б');
+					break;
+				case 0xc2:
+					rez.append('В');
+					break;
+				case 0xc3:
+					rez.append('Г');
+					break;
+				case 0xc4:
+					rez.append('Д');
+					break;
+				case 0xc5:
+					rez.append('Е');
+					break;
+				case 0xc6:
+					rez.append('Ж');
+					break;
+				case 0xc7:
+					rez.append('З');
+					break;
+				case 0xc8:
+					rez.append('И');
+					break;
+				case 0xc9:
+					rez.append('Й');
+					break;
+				case 0xca:
+					rez.append('К');
+					break;
+				case 0xcb:
+					rez.append('Л');
+					break;
+				case 0xcc:
+					rez.append('М');
+					break;
+				case 0xcd:
+					rez.append('Н');
+					break;
+				case 0xce:
+					rez.append('О');
+					break;
+				case 0xcf:
+					rez.append('П');
+					break;
+
+				case 0xd0:
+					rez.append('Р');
+					break;
+				case 0xd1:
+					rez.append('С');
+					break;
+				case 0xd2:
+					rez.append('Т');
+					break;
+				case 0xd3:
+					rez.append('У');
+					break;
+				case 0xd4:
+					rez.append('Ф');
+					break;
+				case 0xd5:
+					rez.append('Х');
+					break;
+				case 0xd6:
+					rez.append('Ц');
+					break;
+				case 0xd7:
+					rez.append('Ч');
+					break;
+				case 0xd8:
+					rez.append('Ш');
+					break;
+				case 0xd9:
+					rez.append('Щ');
+					break;
+				case 0xda:
+					rez.append('Ъ');
+					break;
+				case 0xdb:
+					rez.append('Ы');
+					break;
+				case 0xdc:
+					rez.append('Ь');
+					break;
+				case 0xdd:
+					rez.append('Э');
+					break;
+				case 0xde:
+					rez.append('Ю');
+					break;
+				case 0xdf:
+					rez.append('Я');
+					break;
+
+				case 0xe0:
+					rez.append('а');
+					break;
+				case 0xe1:
+					rez.append('б');
+					break;
+				case 0xe2:
+					rez.append('в');
+					break;
+				case 0xe3:
+					rez.append('г');
+					break;
+				case 0xe4:
+					rez.append('д');
+					break;
+				case 0xe5:
+					rez.append('е');
+					break;
+				case 0xe6:
+					rez.append('ж');
+					break;
+				case 0xe7:
+					rez.append('з');
+					break;
+				case 0xe8:
+					rez.append('и');
+					break;
+				case 0xe9:
+					rez.append('й');
+					break;
+				case 0xea:
+					rez.append('к');
+					break;
+				case 0xeb:
+					rez.append('л');
+					break;
+				case 0xec:
+					rez.append('м');
+					break;
+				case 0xed:
+					rez.append('н');
+					break;
+				case 0xee:
+					rez.append('о');
+					break;
+				case 0xef:
+					rez.append('п');
+					break;
+
+				case 0xf0:
+					rez.append('р');
+					break;
+				case 0xf1:
+					rez.append('с');
+					break;
+				case 0xf2:
+					rez.append('т');
+					break;
+				case 0xf3:
+					rez.append('у');
+					break;
+				case 0xf4:
+					rez.append('ф');
+					break;
+				case 0xf5:
+					rez.append('х');
+					break;
+				case 0xf6:
+					rez.append('ц');
+					break;
+				case 0xf7:
+					rez.append('ч');
+					break;
+				case 0xf8:
+					rez.append('ш');
+					break;
+				case 0xf9:
+					rez.append('щ');
+					break;
+				case 0xfa:
+					rez.append('ъ');
+					break;
+				case 0xfb:
+					rez.append('ы');
+					break;
+				case 0xfc:
+					rez.append('ь');
+					break;
+				case 0xfd:
+					rez.append('э');
+					break;
+				case 0xfe:
+					rez.append('ю');
+					break;
+				case 0xff:
+					rez.append('я');
+					break;
+				default:
+					rez.append('?');
+			}
+		}
+		return rez.toString();
+	}
+
+
+	public static byte[] toKAZASCII(String str)
+	{
+		byte[] rez = new byte[str.length()];
+		for (int i = 0; i < str.length(); i++)
+		{
+			switch (str.charAt(i))
+			{
+				case 0x00:
+					rez[i] = (byte) 0x00;
+					break;
+				case 0x01:
+					rez[i] = (byte) 0x01;
+					break;
+				case 0x02:
+					rez[i] = (byte) 0x02;
+					break;
+				case 0x03:
+					rez[i] = (byte) 0x03;
+					break;
+				case 0x04:
+					rez[i] = (byte) 0x04;
+					break;
+				case 0x05:
+					rez[i] = (byte) 0x05;
+					break;
+				case 0x06:
+					rez[i] = (byte) 0x06;
+					break;
+				case 0x07:
+					rez[i] = (byte) 0x07;
+					break;
+				case 0x08:
+					rez[i] = (byte) 0x08;
+					break;
+				case 0x09:
+					rez[i] = (byte) 0x09;
+					break;
+				case 0x0a:
+					rez[i] = (byte) 0x0a;
+					break;
+				case 0x0b:
+					rez[i] = (byte) 0x0b;
+					break;
+				case 0x0c:
+					rez[i] = (byte) 0x0c;
+					break;
+				case 0x0d:
+					rez[i] = (byte) 0x0d;
+					break;
+				case 0x0e:
+					rez[i] = (byte) 0x0e;
+					break;
+				case 0x0f:
+					rez[i] = (byte) 0x0f;
+					break;
+				case 0x10:
+					rez[i] = (byte) 0x10;
+					break;
+				case 0x11:
+					rez[i] = (byte) 0x11;
+					break;
+				case 0x12:
+					rez[i] = (byte) 0x12;
+					break;
+				case 0x13:
+					rez[i] = (byte) 0x13;
+					break;
+				case 0x14:
+					rez[i] = (byte) 0x14;
+					break;
+				case 0x15:
+					rez[i] = (byte) 0x15;
+					break;
+				case 0x16:
+					rez[i] = (byte) 0x16;
+					break;
+				case 0x17:
+					rez[i] = (byte) 0x17;
+					break;
+				case 0x18:
+					rez[i] = (byte) 0x18;
+					break;
+				case 0x19:
+					rez[i] = (byte) 0x19;
+					break;
+				case 0x1a:
+					rez[i] = (byte) 0x1a;
+					break;
+				case 0x1b:
+					rez[i] = (byte) 0x1b;
+					break;
+				case 0x1c:
+					rez[i] = (byte) 0x1c;
+					break;
+				case 0x1d:
+					rez[i] = (byte) 0x1d;
+					break;
+				case 0x1e:
+					rez[i] = (byte) 0x1e;
+					break;
+				case 0x1f:
+					rez[i] = (byte) 0x1f;
+					break;
+				case ' ':
+					rez[i] = (byte) 0x20;
+					break;
+				case '!':
+					rez[i] = (byte) 0x21;
+					break;
+				case '"':
+					rez[i] = (byte) 0x22;
+					break;
+				case '#':
+					rez[i] = (byte) 0x23;
+					break;
+				case '$':
+					rez[i] = (byte) 0x24;
+					break;
+				case '%':
+					rez[i] = (byte) 0x25;
+					break;
+				case '&':
+					rez[i] = (byte) 0x26;
+					break;
+				case '\'':
+					rez[i] = (byte) 0x27;
+					break;
+				case '(':
+					rez[i] = (byte) 0x28;
+					break;
+				case ')':
+					rez[i] = (byte) 0x29;
+					break;
+				case '*':
+					rez[i] = (byte) 0x2a;
+					break;
+				case '+':
+					rez[i] = (byte) 0x2b;
+					break;
+				case ',':
+					rez[i] = (byte) 0x2c;
+					break;
+				case '-':
+					rez[i] = (byte) 0x2d;
+					break;
+				case '.':
+					rez[i] = (byte) 0x2e;
+					break;
+				case '/':
+					rez[i] = (byte) 0x2f;
+					break;
+				case '0':
+					rez[i] = (byte) 0x30;
+					break;
+				case '1':
+					rez[i] = (byte) 0x31;
+					break;
+				case '2':
+					rez[i] = (byte) 0x32;
+					break;
+				case '3':
+					rez[i] = (byte) 0x33;
+					break;
+				case '4':
+					rez[i] = (byte) 0x34;
+					break;
+				case '5':
+					rez[i] = (byte) 0x35;
+					break;
+				case '6':
+					rez[i] = (byte) 0x36;
+					break;
+				case '7':
+					rez[i] = (byte) 0x37;
+					break;
+				case '8':
+					rez[i] = (byte) 0x38;
+					break;
+				case '9':
+					rez[i] = (byte) 0x39;
+					break;
+				case ':':
+					rez[i] = (byte) 0x3a;
+					break;
+				case ';':
+					rez[i] = (byte) 0x3b;
+					break;
+				case '<':
+					rez[i] = (byte) 0x3c;
+					break;
+				case '=':
+					rez[i] = (byte) 0x3d;
+					break;
+				case '>':
+					rez[i] = (byte) 0x3e;
+					break;
+				case '?':
+					rez[i] = (byte) 0x3f;
+					break;
+				case '@':
+					rez[i] = (byte) 0x40;
+					break;
+				case 'A':
+					rez[i] = (byte) 0x41;
+					break;
+				case 'B':
+					rez[i] = (byte) 0x42;
+					break;
+				case 'C':
+					rez[i] = (byte) 0x43;
+					break;
+				case 'D':
+					rez[i] = (byte) 0x44;
+					break;
+				case 'E':
+					rez[i] = (byte) 0x45;
+					break;
+				case 'F':
+					rez[i] = (byte) 0x46;
+					break;
+				case 'G':
+					rez[i] = (byte) 0x47;
+					break;
+				case 'H':
+					rez[i] = (byte) 0x48;
+					break;
+				case 'I':
+					rez[i] = (byte) 0x49;
+					break;
+				case 'J':
+					rez[i] = (byte) 0x4a;
+					break;
+				case 'K':
+					rez[i] = (byte) 0x4b;
+					break;
+				case 'L':
+					rez[i] = (byte) 0x4c;
+					break;
+				case 'M':
+					rez[i] = (byte) 0x4d;
+					break;
+				case 'N':
+					rez[i] = (byte) 0x4e;
+					break;
+				case 'O':
+					rez[i] = (byte) 0x4f;
+					break;
+				case 'P':
+					rez[i] = (byte) 0x50;
+					break;
+				case 'Q':
+					rez[i] = (byte) 0x51;
+					break;
+				case 'R':
+					rez[i] = (byte) 0x52;
+					break;
+				case 'S':
+					rez[i] = (byte) 0x53;
+					break;
+				case 'T':
+					rez[i] = (byte) 0x54;
+					break;
+				case 'U':
+					rez[i] = (byte) 0x55;
+					break;
+				case 'V':
+					rez[i] = (byte) 0x56;
+					break;
+				case 'W':
+					rez[i] = (byte) 0x57;
+					break;
+				case 'X':
+					rez[i] = (byte) 0x58;
+					break;
+				case 'Y':
+					rez[i] = (byte) 0x59;
+					break;
+				case 'Z':
+					rez[i] = (byte) 0x5a;
+					break;
+				case '[':
+					rez[i] = (byte) 0x5b;
+					break;
+				case '\\':
+					rez[i] = (byte) 0x5c;
+					break;
+				case ']':
+					rez[i] = (byte) 0x5d;
+					break;
+				case '^':
+					rez[i] = (byte) 0x5e;
+					break;
+				case '_':
+					rez[i] = (byte) 0x5f;
+					break;
+				case '`':
+					rez[i] = (byte) 0x60;
+					break;
+				case 'a':
+					rez[i] = (byte) 0x61;
+					break;
+				case 'b':
+					rez[i] = (byte) 0x62;
+					break;
+				case 'c':
+					rez[i] = (byte) 0x63;
+					break;
+				case 'd':
+					rez[i] = (byte) 0x64;
+					break;
+				case 'e':
+					rez[i] = (byte) 0x65;
+					break;
+				case 'f':
+					rez[i] = (byte) 0x66;
+					break;
+				case 'g':
+					rez[i] = (byte) 0x67;
+					break;
+				case 'h':
+					rez[i] = (byte) 0x68;
+					break;
+				case 'i':
+					rez[i] = (byte) 0x69;
+					break;
+				case 'j':
+					rez[i] = (byte) 0x6a;
+					break;
+				case 'k':
+					rez[i] = (byte) 0x6b;
+					break;
+				case 'l':
+					rez[i] = (byte) 0x6c;
+					break;
+				case 'm':
+					rez[i] = (byte) 0x6d;
+					break;
+				case 'n':
+					rez[i] = (byte) 0x6e;
+					break;
+				case 'o':
+					rez[i] = (byte) 0x6f;
+					break;
+				case 'p':
+					rez[i] = (byte) 0x70;
+					break;
+				case 'q':
+					rez[i] = (byte) 0x71;
+					break;
+				case 'r':
+					rez[i] = (byte) 0x72;
+					break;
+				case 's':
+					rez[i] = (byte) 0x73;
+					break;
+				case 't':
+					rez[i] = (byte) 0x74;
+					break;
+				case 'u':
+					rez[i] = (byte) 0x75;
+					break;
+				case 'v':
+					rez[i] = (byte) 0x76;
+					break;
+				case 'w':
+					rez[i] = (byte) 0x77;
+					break;
+				case 'x':
+					rez[i] = (byte) 0x78;
+					break;
+				case 'y':
+					rez[i] = (byte) 0x79;
+					break;
+				case 'z':
+					rez[i] = (byte) 0x7a;
+					break;
+				case '{':
+					rez[i] = (byte) 0x7b;
+					break;
+				case '|':
+					rez[i] = (byte) 0x7c;
+					break;
+				case '}':
+					rez[i] = (byte) 0x7d;
+					break;
+				case '~':
+					rez[i] = (byte) 0x7e;
+					break;
+				case '×':
+					rez[i] = (byte) 0x7f;
+					break; //?
+				//case L' ': rez[i]=(byte)0x80; break;
+				case 'Ғ':
+					rez[i] = (byte) 0x81;
+					break;
+				//case L' ': rez[i]=(byte)0x82; break;
+				case 'ғ':
+					rez[i] = (byte) 0x83;
+					break;
+				//case L' ': rez[i]=(byte)0x84; break;
+				//case L' ': rez[i]=(byte)0x85; break;
+				//case L' ': rez[i]=(byte)0x86; break;
+				//case L' ': rez[i]=(byte)0x87; break;
+				//case L' ': rez[i]=(byte)0x88; break;
+				case '№':
+					rez[i] = (byte) 0x89;
+					break;
+				case 'Ә':
+					rez[i] = (byte) 0x8a;
+					break;
+				//case L' ': rez[i]=(byte)0x8b; break;
+				case 'Ң':
+					rez[i] = (byte) 0x8c;
+					break;
+				case 'Қ':
+					rez[i] = (byte) 0x8D;
+					break;
+				case 'Һ':
+					rez[i] = (byte) 0x8E;
+					break;
+				//case L' ': rez[i]=(byte)0x8f; break;
+				//case L' ': rez[i]=(byte)0x90; break;
+				//case L' ': rez[i]=(byte)0x91; break;
+				//case L' ': rez[i]=(byte)0x92; break;
+				//case L' ': rez[i]=(byte)0x93; break;
+				//case L' ': rez[i]=(byte)0x94; break;
+				//case L' ': rez[i]=(byte)0x95; break;
+				//case L' ': rez[i]=(byte)0x96; break;
+				//case L' ': rez[i]=(byte)0x97; break;
+				//case L' ': rez[i]=(byte)0x98; break;
+				//case L' ': rez[i]=(byte)0x99; break;
+				case 'ә':
+					rez[i] = (byte) 0x9a;
+					break;
+				//case L' ': rez[i]=(byte)0x9b; break;
+				case 'ң':
+					rez[i] = (byte) 0x9c;
+					break;
+				case 'қ':
+					rez[i] = (byte) 0x9D;
+					break;
+				case 'һ':
+					rez[i] = (byte) 0x9E;
+					break;
+				//case L' ': rez[i]=(byte)0x9f; break;
+				//case L' ': rez[i]=(byte)0xa0; break;
+				case 'Ұ':
+					rez[i] = (byte) 0xA1;
+					break;
+				case 'ұ':
+					rez[i] = (byte) 0xA2;
+					break;
+				//case L' ': rez[i]=(byte)0xA3; break;
+				//case L' ': rez[i]=(byte)0xa4; break;
+				//case L' ': rez[i]=(byte)0xA5; break;
+				//case L' ': rez[i]=(byte)0xa6; break;
+				//case L' ': rez[i]=(byte)0xa7; break;
+				case 'Ё':
+					rez[i] = (byte) 0xa8;
+					break;
+				//case L' ': rez[i]=(byte)0xa9; break;
+				case 'Ө':
+					rez[i] = (byte) 0xAA;
+					break;
+				//case L' ': rez[i]=(byte)0xab; break;
+				//case L' ': rez[i]=(byte)0xac; break;
+				//case L' ': rez[i]=(byte)0xad; break;
+				//case L' ': rez[i]=(byte)0xae; break;
+				case 'Ү':
+					rez[i] = (byte) 0xAF;
+					break;
+				//case L' ': rez[i]=(byte)0xb0; break;
+				//case L' ': rez[i]=(byte)0xb1; break;
+				case 'І':
+					rez[i] = (byte) 0xb2;
+					break;
+				case 'і':
+					rez[i] = (byte) 0xb3;
+					break;
+				//case L' ': rez[i]=(byte)0xB4; break;
+				//case L' ': rez[i]=(byte)0xb5; break;
+				//case L' ': rez[i]=(byte)0xb6; break;
+				//case L' ': rez[i]=(byte)0xb7; break;
+				case 'ё':
+					rez[i] = (byte) 0xb8;
+					break;
+				//case L' ': rez[i]=(byte)0xb9; break;
+				case 'ө':
+					rez[i] = (byte) 0xBA;
+					break;
+				//case L' ': rez[i]=(byte)0xbb; break;
+				//case L' ': rez[i]=(byte)0xBC; break;
+				//case L' ': rez[i]=(byte)0xBD; break;
+				//case L' ': rez[i]=(byte)0xBE; break;
+				case 'ү':
+					rez[i] = (byte) 0xBF;
+					break;
+				case 'А':
+					rez[i] = (byte) 0xc0;
+					break;
+				case 'Б':
+					rez[i] = (byte) 0xc1;
+					break;
+				case 'В':
+					rez[i] = (byte) 0xc2;
+					break;
+				case 'Г':
+					rez[i] = (byte) 0xc3;
+					break;
+				case 'Д':
+					rez[i] = (byte) 0xc4;
+					break;
+				case 'Е':
+					rez[i] = (byte) 0xc5;
+					break;
+				case 'Ж':
+					rez[i] = (byte) 0xc6;
+					break;
+				case 'З':
+					rez[i] = (byte) 0xc7;
+					break;
+				case 'И':
+					rez[i] = (byte) 0xc8;
+					break;
+				case 'Й':
+					rez[i] = (byte) 0xc9;
+					break;
+				case 'К':
+					rez[i] = (byte) 0xca;
+					break;
+				case 'Л':
+					rez[i] = (byte) 0xcb;
+					break;
+				case 'М':
+					rez[i] = (byte) 0xcc;
+					break;
+				case 'Н':
+					rez[i] = (byte) 0xcd;
+					break;
+				case 'О':
+					rez[i] = (byte) 0xce;
+					break;
+				case 'П':
+					rez[i] = (byte) 0xcf;
+					break;
+				case 'Р':
+					rez[i] = (byte) 0xd0;
+					break;
+				case 'С':
+					rez[i] = (byte) 0xd1;
+					break;
+				case 'Т':
+					rez[i] = (byte) 0xd2;
+					break;
+				case 'У':
+					rez[i] = (byte) 0xd3;
+					break;
+				case 'Ф':
+					rez[i] = (byte) 0xd4;
+					break;
+				case 'Х':
+					rez[i] = (byte) 0xd5;
+					break;
+				case 'Ц':
+					rez[i] = (byte) 0xd6;
+					break;
+				case 'Ч':
+					rez[i] = (byte) 0xd7;
+					break;
+				case 'Ш':
+					rez[i] = (byte) 0xd8;
+					break;
+				case 'Щ':
+					rez[i] = (byte) 0xd9;
+					break;
+				case 'Ъ':
+					rez[i] = (byte) 0xda;
+					break;
+				case 'Ы':
+					rez[i] = (byte) 0xdb;
+					break;
+				case 'Ь':
+					rez[i] = (byte) 0xdc;
+					break;
+				case 'Э':
+					rez[i] = (byte) 0xdd;
+					break;
+				case 'Ю':
+					rez[i] = (byte) 0xde;
+					break;
+				case 'Я':
+					rez[i] = (byte) 0xdf;
+					break;
+				case 'а':
+					rez[i] = (byte) 0xe0;
+					break;
+				case 'б':
+					rez[i] = (byte) 0xe1;
+					break;
+				case 'в':
+					rez[i] = (byte) 0xe2;
+					break;
+				case 'г':
+					rez[i] = (byte) 0xe3;
+					break;
+				case 'д':
+					rez[i] = (byte) 0xe4;
+					break;
+				case 'е':
+					rez[i] = (byte) 0xe5;
+					break;
+				case 'ж':
+					rez[i] = (byte) 0xe6;
+					break;
+				case 'з':
+					rez[i] = (byte) 0xe7;
+					break;
+				case 'и':
+					rez[i] = (byte) 0xe8;
+					break;
+				case 'й':
+					rez[i] = (byte) 0xe9;
+					break;
+				case 'к':
+					rez[i] = (byte) 0xea;
+					break;
+				case 'л':
+					rez[i] = (byte) 0xeb;
+					break;
+				case 'м':
+					rez[i] = (byte) 0xec;
+					break;
+				case 'н':
+					rez[i] = (byte) 0xed;
+					break;
+				case 'о':
+					rez[i] = (byte) 0xee;
+					break;
+				case 'п':
+					rez[i] = (byte) 0xef;
+					break;
+				case 'р':
+					rez[i] = (byte) 0xf0;
+					break;
+				case 'с':
+					rez[i] = (byte) 0xf1;
+					break;
+				case 'т':
+					rez[i] = (byte) 0xf2;
+					break;
+				case 'у':
+					rez[i] = (byte) 0xf3;
+					break;
+				case 'ф':
+					rez[i] = (byte) 0xf4;
+					break;
+				case 'х':
+					rez[i] = (byte) 0xf5;
+					break;
+				case 'ц':
+					rez[i] = (byte) 0xf6;
+					break;
+				case 'ч':
+					rez[i] = (byte) 0xf7;
+					break;
+				case 'ш':
+					rez[i] = (byte) 0xf8;
+					break;
+				case 'щ':
+					rez[i] = (byte) 0xf9;
+					break;
+				case 'ъ':
+					rez[i] = (byte) 0xfa;
+					break;
+				case 'ы':
+					rez[i] = (byte) 0xfb;
+					break;
+				case 'ь':
+					rez[i] = (byte) 0xfc;
+					break;
+				case 'э':
+					rez[i] = (byte) 0xfd;
+					break;
+				case 'ю':
+					rez[i] = (byte) 0xfe;
+					break;
+				case 'я':
+					rez[i] = (byte) 0xff;
+					break;
+				default:
+					rez[i] = (byte) 0x20;
+			}
+		}
+		return rez;
+	}
+}