From 6cd3bb5e65c2540719798e2d35e50050611ab42d Mon Sep 17 00:00:00 2001
From: igor <irigm@mail.ru>
Date: Mon, 18 Nov 2024 22:17:38 +0500
Subject: [PATCH] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B2=D1=8B=D0=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 DBTools.java                |   89 ++
 EmailUtility.java           |   65 +
 PreparedStatementNamed.java |  218 +++
 STools.java                 |   39 +
 Translation.java            |   82 ++
 User.java                   |   45 +
 XMLTools.java               |  189 +++
 tctable/Point.java          |   14 +
 tctable/TCField.java        |  574 ++++++++
 tctable/TCTable.java        |  200 +++
 tctable/TCTableTools.java   |   74 +
 tctable/Tools.java          | 2529 +++++++++++++++++++++++++++++++++++
 12 files changed, 4118 insertions(+)
 create mode 100644 DBTools.java
 create mode 100644 EmailUtility.java
 create mode 100644 PreparedStatementNamed.java
 create mode 100644 STools.java
 create mode 100644 Translation.java
 create mode 100644 User.java
 create mode 100644 XMLTools.java
 create mode 100644 tctable/Point.java
 create mode 100644 tctable/TCField.java
 create mode 100644 tctable/TCTable.java
 create mode 100644 tctable/TCTableTools.java
 create mode 100644 tctable/Tools.java

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;
+	}
+}