[JAVA] 基于TCP的起重机运行模拟器

1、客户端

 package ClientMain;

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Scanner;

 public class TcpClient {
     public static void main(String[] args) throws IOException {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
         Socket s = null;
         DataInputStream DataIn = null;
         DataOutputStream DataOut = null;
         try {
             // s=new Socket(InetAddress.getByName("192.168.1.130"),8000);
             s = new Socket("localhost", 8000);
             DataIn = new DataInputStream(s.getInputStream());
             DataOut = new DataOutputStream(s.getOutputStream());
             System.out.println("连接成功");
             @SuppressWarnings("resource")
             Scanner keyIn = new Scanner(System.in);
             while (keyIn.hasNext()) {
                 String c = keyIn.nextLine();
                 System.out.println("输入命令为: " + c);
                 if (c.length() == 0)
                     continue;
                 char inputchar = c.charAt(0);// 输入命令取字符串的第一个
                 switch (inputchar) {
                 case 'a':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行大车前移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 大车前移命令
                 case 'b':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行大车后移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 大车后移命令
                 case 'c':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行大车停止命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 大车停止命令
                 case 'd':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行小车前移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 小车前移命令
                 case 'e':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行小车后移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 小车后移命令
                 case 'f':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行小车停止命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 小车停止命令
                 case 'g':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行吊钩上移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 吊钩上移命令
                 case 'h':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行吊钩下移命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 吊钩下移命令
                 case 'i':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行吊钩停止命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte());
                     break;// 吊钩停止命令
                 case 'j':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取大车位置命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取大车位置
                 case 'k':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取小车位置命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取小车位置
                 case 'l':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取吊钩位置命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取吊钩位置
                 case 'm':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取大车速度命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取大车速度
                 case 'n':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取小车速度命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取小车速度
                 case 'o':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取吊钩速度命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取吊钩速度
                 case 'p':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date()) + " : 执行获取重物重量命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取重物重量
                 case 'q':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date())
                             + " : 执行获取机器本次工作时间命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取机器本次工作时间
                 case 'r':
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date())
                             + " : 执行获取机器总工作次数命令");// 服务器日志信息
                     System.out.println("服务器返回数据: " + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte()
                             + (char) DataIn.readByte());
                     break;// 获取机器总工作次数
                 case 's':// [留待以后扩展]
                     DataOut.writeByte(inputchar);
                     System.out.println(df.format(new Date())
                             + " : 执行获取机器工作状态命令");// 服务器日志信息
                     break;// 获取机器工作状态
                 default:
                     System.out.println(df.format(new Date()) + " : 输入命令有误！");// 服务器日志信息
                     break;// 错误操作
                 }
             }
             DataIn.close();
             DataOut.close();
             s.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         DataIn.close();
         DataOut.close();
         s.close();
     }
 }

TcpClient.java

---

2、服务器

 package ServerMain;

 import java.awt.Graphics2D;

 public class Qzj {
     public static final int GO = 1, BACK = -1, STOP = 0;// 3种运动状态
     public Car big, small, hook;// 声明大车，小车和吊钩
     public int weight;// 称重重量[0-99999kg]
     public int all_work_times;// 总工作次数[0-99999次]
     public int this_time;// 本次工作时长[0-99999分钟]
     public int work_state;// 机器工作状态[留待]

     Qzj() {// 这里偷下懒，一口气把所有参数写进来太麻烦干脆直接在这里修改吧
         big = new Car(5000, 5, STOP, 0, 10000, 500, 9500, 8);// 大车初始位置为50米处，速度为5dm/s,停止状态，没有警报，轨道100m,左右限位，最大速度为8dm/s
         small = new Car(100, 2, STOP, 0, 2000, 100, 1900, 5);
         hook = new Car(0, -2, STOP, 0, 1000, 50, 950, 4);
         weight = new java.util.Random().nextInt() % 100000;
         all_work_times = new java.util.Random().nextInt() % 100000;
         this_time = new java.util.Random().nextInt() % 100000;
         work_state = 0;

         Thread t1 = new Thread(big);
         Thread t2 = new Thread(small);
         Thread t3 = new Thread(hook);

         t1.start();
         t2.start();
         t3.start();
     }

     public class Car implements Runnable {
         public int position;// 当前车的位置0-99999cm
         public int speed;// 当前车的速度0-99dm/s
         public int state;// 当前车的运动状态[GO,BACK,STOP]
         public int warn;// 当前车是否有限位报警[留待]
         public int length, limit_Lposition, limit_Rposition, limit_speed;// 轨道长度，左限位，右限位[cm]，限速[dm/s]

         Car(int pos, int spe, int sta, int war, int len, int limit_Lpos,
                 int limit_Rpos, int limit_spe) {
             position = pos;
             speed = spe;
             state = sta;
             warn = war;
             length = len;
             limit_Lposition = limit_Lpos;
             limit_Rposition = limit_Rpos;
             limit_speed = limit_spe;
         }// 构造函数

         //将信息显示到屏幕上
         public void showText(Graphics2D gg,int x,int y) {
             gg.drawString("$: 实时信息---位置: "+position+" cm, 速度: "+speed+" dm/s, 状态: "+state+" , 警报: "+warn+" , 轨长: "+length+" cm, 左限位: "+limit_Lposition+" cm, 右限位: "+limit_Rposition+" cm, 限速"+limit_speed+" dm/s",x,y);
         }
         // //获取参数函数系

         void setPos(int pos) {
             position = pos;
         }

         void setSpe(int spe) {
             speed = spe;
         }

         void setSta(int sta) {
             state = sta;
         }

         void setWar(int war) {
             warn = war;
         }

         void setLen(int len) {
             length = len;
         }

         void setLimit_Lpos(int limit_Lpos) {
             limit_Lposition = limit_Lpos;
         }

         void setLimit_Rpos(int limit_Rpos) {
             limit_Rposition = limit_Rpos;
         }

         void setLimit_spe(int limit_spe) {
             limit_speed = limit_spe;
         }

         // //

         // //设置参数函数系
         int getPos() {
             return position;
         }

         int getSpe() {
             return speed;
         }

         int getSta() {
             return state;
         }

         int getWar() {
             return warn;
         }

         int getLen() {
             return length;
         }

         int getLimit_Lpos() {
             return limit_Lposition;
         }

         int getLimit_Rpos() {
             return limit_Rposition;
         }

         int getLimit_spe() {
             return limit_speed;
         }

         // //
         @Override
         public void run() {// 车运动的线程函数
             while (true) {
                 switch (state) {// 运动处理
                 case GO:
                     position += speed*10;//单位转换，因为速度是dm/s其他的是cm为单位
                     break;
                 case BACK:
                     position -= speed*10;//单位转换
                     break;
                 case STOP:
                     break;
                 default:
                     break;
                 }
                 // 限位报警处理
                 if (position > limit_Rposition) {// 超出右限位，停在右限位
                     position = limit_Rposition;
                     state = STOP;
                 } else if (position < limit_Lposition) {// 超出左限位，停在左限位
                     position = limit_Lposition;
                     state = STOP;
                 }
                 // 等待时间
                 try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }
     }
 }

Qzj.java

>_<" 起重机类，这里将大车，小车，勾用类Car来实现，然后分别声明（因为他们有相似点）；至于起重机其他参数就在QZJ的类里面声明~

 package ServerMain;

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 public class TcpServer {

     public static Qzj qzj = new Qzj();// 实例化一个起重机的类
     public static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
     // System.out.println(df.format(new Date()));// new Date()为获取当前系统时间
     public static ServerSocket server;
     public static Socket s = null;
     public static DataOutputStream dataOut = null;
     public static DataInputStream dataIn = null;

     public TcpServer() throws IOException{
         server = new ServerSocket(8000);
         getandsend mes = new getandsend();
         Thread t1 = new Thread(mes);
         t1.start();
     }

     public class getandsend implements Runnable {
         public void run() {
             while (true) {
                 try {
                     s = server.accept();
                     dataOut = new DataOutputStream(s.getOutputStream());
                     dataIn = new DataInputStream(s.getInputStream());
                     while (true) {
                         Byte c = dataIn.readByte();
                         switch (c) {
                         case 'a':
                             dataOut.writeByte('a');
                             qzj.big.state=Qzj.GO;
                             System.out.println(df.format(new Date())
                                     + " : 执行大车前移命令");// 服务器日志信息
                             break;// 大车前移命令
                         case 'b':
                             dataOut.writeByte('b');
                             qzj.big.state=Qzj.BACK;
                             System.out.println(df.format(new Date())
                                     + " : 执行大车后移命令");// 服务器日志信息
                             break;// 大车后移命令
                         case 'c':
                             dataOut.writeByte('c');
                             qzj.big.state=Qzj.STOP;
                             System.out.println(df.format(new Date())
                                     + " : 执行大车停止命令");// 服务器日志信息
                             break;// 大车停止命令
                         case 'd':
                             dataOut.writeByte('d');
                             qzj.small.state=Qzj.GO;
                             System.out.println(df.format(new Date())
                                     + " : 执行小车前移命令");// 服务器日志信息
                             break;// 小车前移命令
                         case 'e':
                             dataOut.writeByte('e');
                             qzj.small.state=Qzj.BACK;
                             System.out.println(df.format(new Date())
                                     + " : 执行小车后移命令");// 服务器日志信息
                             break;// 小车后移命令
                         case 'f':
                             dataOut.writeByte('f');
                             qzj.small.state=Qzj.STOP;
                             System.out.println(df.format(new Date())
                                     + " : 执行小车停止命令");// 服务器日志信息
                             break;// 小车停止命令
                         case 'g':
                             dataOut.writeByte('g');
                             qzj.hook.state=Qzj.GO;
                             System.out.println(df.format(new Date())
                                     + " : 执行吊钩上移命令");// 服务器日志信息
                             break;// 吊钩上移命令
                         case 'h':
                             dataOut.writeByte('h');
                             qzj.hook.state=Qzj.BACK;
                             System.out.println(df.format(new Date())
                                     + " : 执行吊钩下移命令");// 服务器日志信息
                             break;// 吊钩下移命令
                         case 'i':
                             dataOut.writeByte('i');
                             qzj.hook.state=Qzj.STOP;
                             System.out.println(df.format(new Date())
                                     + " : 执行吊钩停止命令");// 服务器日志信息
                             break;// 吊钩停止命令
                         case 'j':
                             sendstring(dataOut, qzj.big.getPos(), 6, 'j');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取大车位置命令");// 服务器日志信息
                             break;// 获取大车位置
                         case 'k':
                             sendstring(dataOut, qzj.small.getPos(), 6, 'k');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取小车位置命令");// 服务器日志信息
                             break;// 获取小车位置
                         case 'l':
                             sendstring(dataOut, qzj.hook.getPos(), 6, 'l');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取吊钩位置命令");// 服务器日志信息
                             break;// 获取吊钩位置
                         case 'm':
                             sendstring(dataOut, qzj.big.getSpe(), 3, 'm');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取大车速度命令");// 服务器日志信息
                             break;// 获取大车速度
                         case 'n':
                             sendstring(dataOut, qzj.small.getSpe(), 3, 'n');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取小车速度命令");// 服务器日志信息
                             break;// 获取小车速度
                         case 'o':
                             sendstring(dataOut, qzj.hook.getSpe(), 3, 'o');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取吊钩速度命令");// 服务器日志信息
                             break;// 获取吊钩速度
                         case 'p':
                             sendstring(dataOut, qzj.weight, 6, 'p');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取重物重量命令");// 服务器日志信息
                             break;// 获取重物重量
                         case 'q':
                             sendstring(dataOut, qzj.this_time, 6, 'q');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取机器本次工作时间命令");// 服务器日志信息
                             break;// 获取机器本次工作时间
                         case 'r':
                             sendstring(dataOut, qzj.all_work_times, 6, 'r');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取机器总工作次数命令");// 服务器日志信息
                             break;// 获取机器总工作次数
                         case 's':// [留待以后扩展]
                             sendstring(dataOut, qzj.work_state, 6, 's');
                             System.out.println(df.format(new Date())
                                     + " : 执行获取机器工作状态命令");// 服务器日志信息
                             break;// 获取机器工作状态
                         default:
                             break;// 错误操作
                         }
                     }
                 } catch (IOException e) {
                 }finally{
                     try {
                         dataOut.close();
                         dataIn.close();
                         s.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     }

     // 将int类的data转换为i-1位字符串并加上c结尾发送出去函数
     private static void sendstring(DataOutputStream dataOut, int data, int i,
             char c) throws IOException {
         switch (i) {
         case 6:
             dataOut.writeByte((char) (data / 10000 + '0'));
             data %= 10000;
         case 5:
             dataOut.writeByte((char) (data / 1000 + '0'));
             data %= 1000;
         case 4:
             dataOut.writeByte((char) (data / 100 + '0'));
             data %= 100;
         case 3:
             dataOut.writeByte((char) (data / 10 + '0'));
             data %= 10;
         case 2:
             dataOut.writeByte((char) (data + '0'));
         case 1:
             dataOut.writeByte(c);
         }
     }

     public static void main(String[] args) throws IOException {
         new TcpServer();
     }
 }

TcpServer.java

>_<" TCP服务器，负责接收客户端命令和处理命令~

 package ServerMain;

 import javax.swing.*;
 import java.awt.*;
 import java.io.IOException;

 final class Draw extends JFrame implements Runnable {

     public static TcpServer tcp;

     Draw() throws HeadlessException, IOException {
         super();
         Container container = getContentPane();
         container.add(canvas, BorderLayout.CENTER);//把canvas加入中间
         pack();
         tcp=new TcpServer();//使命并实例化一个TCP服务器并启动
     }

     private final static JComponent canvas = new JComponent() {
         protected void paintComponent(Graphics g) {
             super.paintComponent(g);
             drawQZJ(g);
             drawText(g);
         }

         //http://www.weixueyuan.net/view/6074.html Graphics资料
         //绘制起重机3维图像
         private  int a=10,b=90,wid=600,len=380;//矩形框的位置和大小
         public void drawQZJ(Graphics g){
             Graphics2D gg=(Graphics2D)g;
             gg.setColor(Color.BLUE);
             gg.fillRect(0 , 0 , 800 , 480);
             gg.setColor(Color.YELLOW);
             gg.fillRect(a, b , wid, len);
             gg.setColor(Color.BLACK);
             gg.drawRect(a, b , wid, len);
             Stroke stroke=new BasicStroke(2.0f);//设置线宽为2.0
             gg.setStroke(stroke);
             gg.setColor(Color.BLACK);
             //最长横梁边距为15，间距为100
             gg.drawLine(a+15, b+15,wid+a-15, b+15);
             gg.drawLine(a+15, b+115,wid+a-15, b+115);
             //画大车，将位置经过比例运算展现，这里位置默认为大车中间位置，所以前后伸长25
             gg.drawLine(a+15-25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(), b+5,a+15-25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(), b+125);
             gg.drawLine(a+15+25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(), b+5,a+15+25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(), b+125);
             //画小车
             gg.setColor(Color.RED);
             gg.drawLine(a+15-25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen()-10, b+15+tcp.qzj.small.getPos()*100/tcp.qzj.small.getLen(),a+15+25+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen()+10, b+15+tcp.qzj.small.getPos()*100/tcp.qzj.small.getLen());
             //画勾
             gg.setColor(Color.BLACK);
             gg.drawLine(a+15,b+175,wid+a-15,b+175);//横轨
             stroke=new BasicStroke(1.0f);//设置线宽为1.0
             gg.setStroke(stroke);
             gg.drawRect(a+15-4+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),b+175-4,8,6);//滑块8X6
             gg.drawLine(a+15+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),b+175+2,a+15+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2);//中间的线
             gg.fillRect(a+15-3+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2,7,6);//下面的小方块7X6
             gg.drawLine(a+15+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2+6,a+15+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2+6+3);//下面是画最下面的勾
             gg.drawRect(a+15-6+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2+6+3,12,6);//负载12X6
             gg.setColor(Color.YELLOW);
             gg.fillRect(a+15-6-1+tcp.qzj.big.getPos()*(wid-30)/tcp.qzj.big.getLen(),tcp.qzj.hook.getPos()*170/tcp.qzj.hook.getLen()+b+175+2+6+3-1,7,4);//画一个黄色的矩形将上面的矩形变成一个勾

         }

         //显示起重机信息
         private void drawText(Graphics g) {
             Graphics2D gg=(Graphics2D)g;
             gg.setColor(Color.BLACK);
             //右边上部分显示起重机的整体运动实时参数
             gg.drawString("$ 称重重量: "+tcp.qzj.weight+" [kg]",620,100);//weight
             gg.drawString("$ 总工作次数: "+tcp.qzj.all_work_times+" [次]",620,120);//all_work_times
             gg.drawString("$ 本次工作时长: "+tcp.qzj.this_time+" [分钟]",620,140);//this_time
             gg.drawString("$ 机器工作状态: "+tcp.qzj.work_state+" [留待]",620,160);//work_state
             gg.drawLine(620, 165, 760, 165);
             //右下部分显示客户端TCP发送过来的控制命令
             gg.drawString("$ 大车前移命令: a",620,180);
             gg.drawString("$ 大车后移命令: b",620,195);
             gg.drawString("$ 大车停止命令: c",620,210);
             gg.drawString("$ 小车前移命令: d",620,225);
             gg.drawString("$ 小车后移命令: e",620,240);
             gg.drawString("$ 小车停止命令: f",620,255);
             gg.drawString("$ 吊钩上移命令: g",620,270);
             gg.drawString("$ 吊钩下移命令: h",620,285);
             gg.drawString("$ 吊钩停止命令: i",620,300);
             gg.drawString("$ 获取大车位置: j",620,315);
             gg.drawString("$ 获取小车位置: k",620,330);
             gg.drawString("$ 获取吊钩位置: l",620,345);
             gg.drawString("$ 获取大车速度: m",620,360);
             gg.drawString("$ 获取小车速度: n",620,375);
             gg.drawString("$ 获取吊钩速度: o",620,390);
             gg.drawString("$ 获取重物重量: p",620,405);
             gg.drawString("$ 本次工作时间: q",620,420);
             gg.drawString("$ 总的工作次数: r",620,435);
             gg.drawString("$ 获取工作状态: s",620,450);
             //上面一部分显示实时信息
             gg.drawString("$----嵌入式操作系统Java模拟机,第1.0版,2014-9-18-3:15----$",230,20);//标题
             tcp.qzj.big.showText(gg, 10, 50);
             tcp.qzj.small.showText(gg, 10, 65);
             tcp.qzj.hook.showText(gg, 10, 80);    

         }

     };//canvas

     @Override
     public void run() {//每隔一定时间进行绘制
         while(true){
             canvas.repaint();
             try {
                 Thread.sleep(100);
             }catch (Exception e){}
         }
     }

     public static void main(String[] args) throws IOException {
         //绘图窗口实例化并启动刷新进程
         Draw show=new Draw();
         show.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         show.setSize(800,518);
         show.setVisible(true);
         Thread t2 = new Thread(show);
         t2.start();
     }
 }

Draw.java

>_<" 负责绘制模拟起重机运动界面，实现模拟起重机的功能~

---

3、效果展示

>_<" 最终实现客户端在consoles里输入相应命令，然后通过TCP把数据传输至网络另一端的服务器，另一端的服务器根据不同的命令做出相应的回应及控制动作~这里运行的时候要先运行服务器部分，是draw文件，不是tcpserver文件，因为总的启动函数在draw中，客户端就直接运行但是要在服务器之后~(虽然这是最基本的知识了，但是还是要说一下~),此外每次调试的时候要先关闭客户端，再关闭服务器，如果一切正常启动服务器有错误，就检查一下consoles里是否服务器已经关闭(因为每次只能开一个服务器,没关闭上一个，端口就没有释放所以就报错)

aaarticlea/png;base64,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" alt="" />

[图1 服务器模拟端界面]

aaarticlea/png;base64,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" alt="" />

[图2 客户端Console部分]

aaarticlea/png;base64,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" alt="" />

[图3 服务器端consoles部分]

---

4、通信协议

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAA2kAAAF6CAIAAAAMN4ftAAAgAElEQVR4nO29z6pkS7LmF4/Xs5pKiEYCob8ghP7QCCG4dKMGvUC+whmdSZLkJEHPcUSxaySogSbq063bdbvq1g0N8lSw0t3888/MfcWO2PH7+NhE+LJlbm5ubma5IvbOy+ev3yCEEEIIIXR4+fz12+/+5f8J4Z35089fsnx3m+FTk5CDEMKGhcT46csv9I7wffjTz1/+6Xr1SSGHiyTkIISwYSExqt7xer1er9f+taYvWZNfuQs+FH/6+cs/ZeAU8lRg9MLh7bWDUJOHp/KMkLvxesB2y6/X65//8a+mDe/uZ7iRZpqaXoJwxEJidHvH/q1zi8NsV/pdmBPyAfjTz1/++td/8jkq5KPebtoIOvJT/SIOF5sJgnw7t4RcGAPTcj6F0P+7Q+84nWjFP4Tc4/C49aMX4q7fDQJPyMOXZSExDnvHVLKbyo8sdm4Rg+/ucbjCn37+8o//+Fef2d6xfysGBXv908DWVmUnhbu4PeScbUqFSj9yvV7/n3/zp+v1+ud//OtIlUikfhQRco/G0VbqMPjdIWamyVCMw9dhITFOekd/7kJchpdMPSspEj4If/r5y1/+8lef5kOg6bzHDKsDqRnv0/FoUlNsauEd+C7HZ33SmoYtIfe7LoQWd9MJoav8zHo0he8iQu7RzI5zU5S4+k28ZnpHfQm+AguJMe4dRZiOzs9ITAj/X//3r7Xg7sUI/WfkTz9/+fNf/tGn6B2n0JZomWzs3Ub88E7Zs5emi06a984atoRc6D0Rb0089JJiIWY8j8QIub1rvL/Z/T6OwmYaV9Mwu/N2wMdhITEGveM16uqmHMlP9YwCvREQ2ZC4f1L+9POXf/jzX278V//6//jOv/uX//v/+r/93f/0L/6X/+6//x+OAmYhL1iib9Q5uk/rIl+HAbxrFc/F9WUWNNwh5MTIKDb6EErpF64wXUTI3U1DYbomz4zCqTeyv10Y/yIxAEMWEuP8M+sw/kbJyxQe3TuVcQbhs/Cnn7/86T/85ci/+1f/+hap/+V//d82V3UhT0XaFKO7smss3DW6pbHh+Pb7i9v34fQSrl1rMp1xy1wjhb5PhPF6ro0hF3qjeTva0NB+MR4qFFOMQMilvLE35G4jwn69Kc2L7092wu/P6ODR86acAz8YC4nxPb/v+LsuN031h2f13f0Oa/zp5y///k9/bvg//s//4r/4r/6b//Q/+8/7S07vqJP7UVKPhJpHs5iWpELduXR82+h3XusZxV3mXP4l3yGLS94VcjedzQvtyZEHRnfd+oMeZsyYThZi0w1N+f8FQ66/0TfDiQ1zs6bzpqyCH4yFxPhuzx21/OjgNWdGTwEfnD/9/OXv//2fe/5H//F/Eo6L3jGMBB17+t7RJXMKYeSKmJj9+uPvUgibzRn1qvVcDVZcV/PGaPt2hdxNp+PnUFiM365mfzdrBELuHUMutN+hXtfoV2FuSP2ujO8c+CFZSIxu7xheGtGJUfGVSnEgR7YR98/In37+8u/+/j/43FLI+0vTKBJq/cBLhah5NBrDRsX1d+OS5kwXnsdC01BzXVlhuK3nhZzwcChzFA49PL20JdIIubNDLrS/sC/NkkefWY+cKfbC9wz8qCwkxp294+g819LH8e2x0Qw1E/rPyJ9+/vJv//4ffE7/Rs/vZhWrv0UXg5G8k46FkWV5Ye1VFnJ/gY7NYi5919TVKddpb4Svt4Tc77ow0x6YrlTcEsbbdGfNHSHk7hByof0mRzFmrsW/xfQM/KgsJMY9veO1+2eQE7Wn5hr4+Pzp5y+//n//4HP0iwvOYCjgxPbvZFXQMXwt/cmClCXHt05xLZzEZiJ/rqkZplvMtThi6yFXCInpSs2FiJFC+iXk7hNyof0phpaLtXy/xN8Ghz4LiXHP9x3DSO2VhFM4+rWGd/c7rPGnn7/8m3/3J5/mH0y5tWsiUaYi5yhspuN+uoJ/9Kk5LrNZlHh7jU5oeHX0Vs9lTqf3yNm1rBnfx7eE3Gh1jvECTryNRgrpl5C7T8iJ9fpmNP8EDbWN7HE2N2US/HgsJMYNzx314RFxObrqhHj5KMLH4U8/f/l//+2ffJofIIrxaayG8uUI7y15d5/7DE/cu1u1yPWQy4aQ4zohoKPRsefdfe7zQ4bcojcah+gHzOHtTx0S8D4sJMZh7wjh2fzp5y9ZvrvNL8WPV3IIuQfnxws5CB+fhcT4W+/46csvEEIIIYQQTnn5/PXb2x9/hRBCCCGEUJPeEUIIIYQQupz0jpfLxdEyFRsJOPpNGyCEEEII4dm8U+8YyoiG8niJ3hFCCCGE8EFY7x0vM5hiN+Hmxv72d3cWhBBCCOGLc8Nzx71d3eiJI70jhBBCCOG784fe0X9GeOPx+eJoDlNDqPD4E0IIIYQQvi+XnjuazwXD7rBvOkf9JY0jhBBCCOGDUPWO02d+2WeTodrUY0gIYZZ8YxhnQgjhRi71jr3w6FLfWYre8SZA4wjhInmEjzMhhHAv79Q7CrVNOu4nFU80IYQOOT44E0IId3HYO+p/YYtPq/s+r9A7mmZACKfk+T3OhBDCjSz2jlq+v+R8Zt2PH0fI1BAWyL++cCaEEO5l3DuGDxq1ouxn1uZbc3YIYUjaHZwJIYR7GfSOo5yoc+VJvSPfK4JwkeE3SSDOhBDCGoO/DS6khYDTO/bfgxRfcCQ1QwghhBA+Gid/GxxCCCGEEMIbf+sdP335BUIIIYQQwikvn79+uwLwDPj92x/e2wTwWiDkAACgAb0jeCZQyMGdQcgBAECDSe94uVwcLaZYf9d3nKEcfEhQyMGdQcgBAECDO/WO/Z8HF7c0V+kdwQ0UcnBnEHIAANCg3juG7eCoNXT6v9GN5uNJ8AqgkIM7g5ADAIAGG5477pLpJXn6CBpQyFPgH13ruIUczgQAgO/4oXecPkoUDxR1VvV1NgqPPwGgd8yCs7OIY8jhTAAAuC4+d/SfC6Y+sx51kwDQO2bB8VkEvSMAADRQveP0mZ/5bFIr0ZLmc03wIqB3zOJ2isODCaboe0ecCQB4cSz1jr2wvuo0mreR4yXSNPgOescseIq/iKZ3xJkAAHDv3lHfeGwcm0H+rQ+u9I55jB7kAxPiM2ucCQB4TQx7R/3Pa/FpddjnZXtH0wzwaqB3zIJ2ZxH0jgAA0KDYO2r50SXdOzb9ZfMMkjQNrvSOedDuLILeEQAAGsS9Y/igUSta7x19GfCyoHfMgnZnEfSOAADQIOgdRwnR+UajHp9+tN3r4TuO4Ah6xyzEWQMO+t+VwZkAgBdH8LfBhbQQKH+uPeodyc6gB70juDMIOQAAaDD52+AAPBQo5ODOIOQAAKDBb73jpy+/QAghhBBCOOXl89dvb3/8FUIIIYQQQk16RwghhBBC6HLSO14uF0eLI9bIbNRcEE6phRBCCCGE33nX3lGgprm5NxQOZ6F3hBBCCCEssN476l6wv7HWrul2cGRPTS2EEEIIIdTc8NwxJZPtMs1Hkv4zxdRTTwghhBBCeOQPveP0UWL4tK95EVKIrfeO318cf07p95oQQgghhPDGpeeOfpO38tyxlxzdHqoaaTDXCCGEEEIIb1S94/RJnvNsMvU48HhL/1qIvZ3zaBPCj8HRv9MgzoQQwiyXesdeWF91es23/OPM0QNFoYTeEb4OiXacCSGEG3nv3tG518nOx8axGRx9PD1SSwGAH5iEN86EEMK9HPaOursSTxDDp4nHBk4/dJxOfdTj3DUyYzoFhB+AhDfOhBDCvSz2jlrevOo8hhQ3Nv1oP/4Wtaq9TuoB/MAkvHEmhBDuZdw76meBIe/ZOxZ0Hq/SO8KXIk/ZcSaEEG5k0Ds6Ld2Wq3t7x/Djb2dSCgD88Bx9PwTiTAghzDL42+BCWgikescw+UbfhAzQ6/TzeK3dhBBCCCGE3zn52+AQQgghhBDe+Fvv+OnLLxBCCCGEEE55+fz12xWAZ8Dv3/7w3iaA1wIhBwAADegdwTOBQg7uDEIOAAAaTHrHy+XiaJmKjQQc/aYN4BVAIQd3BiEHAAAN7tQ7hjKioTxeoncEN1DIwZ1ByAEAQIN67zj9Yzqm2E24ubG/fdOSwRODQg7uDEIOAAAabHjuuLerGz1xpHcEVwr5Gvg3WAGjkMOZAICXRdw7Hp8aNi+mkqFM+EgyvLFRePwJAL3jIjhKWYiQw5kAgNeE2zteZ19Y1L1j/zZsT8P+kgQNbqB3XASnKQt6RwAAaBD0jqJvE19GzD5ZHD2w1I8hwYuD3rEAcTbBFE3I4UwAAGh7R93JhSN6/Dr4zFr0jjcBGkfQgN4xi+mJBhrHkMOZAABwbXpHp1Os9Y7929HH4s3VK//QBwfQO2ZBu7MIekcAAGhQ/D1r8Wl13+cVesfQADI1oHfMgnZnEfSOAADQYM/fBteS5mfW/fhxhDQNrvSOedDuLILeEQAAGtypdyy/zZoBPjboHbPQz/XBFKPeEWcCAF4Wj947kqDBEfSOBTTP+zlQKYx+z/qKMwEAr4ph79h8Z3EKp3fsvwcpvuBIXgY96B3BnUHIAQBAg8lzRwAeChRycGcQcgAA0OC33vHTl18ghBBCCCGc8vL567e3P/4KIYQQQgihJr0jhBBCCCF0OekdL5eLo8UU6+/6jjOUQwghhBDC7bxT79j/eXBxS3OV3hFCCCGE8EFY7x3DdnDUGjr93+hG8/EkhBBCCCE8mxueO+6S6SV5+gghhBBC+FCMe8dbo9a/mEqOxMyHlI3C408IIYQQQvi+dHvHt6iB858Lpj6z5vuOEEIIIYSPyaB3FH2b+DKi+LJjf6PgaEY6SAhr5EvDOBNCCDey7R11sxiO6PHjVafRvI0cL5GmIaxxeqIhzoQQwhR/6B2dTnGxd9Q3HhvHZpB/60NY4PQzAYgzIYQwxeLvWY+eII4Sa7Z3HF19d39B+Fzk1OBMCCHcyz1/G1xL6o+em6vHt8cRsjaEBXJwcCaEEO7lA/WOvgyE0KRzviDOhBBCn6f3juKbi+F3hvq3JGgIV8j383AmhBBu5LB3zOZHRzL13JHsDCGEEEL4aJw8d4QQQgghhPDG33rHT19+gRBCCCGEcMrL56/frgA8A37/9of3NgG8Fgg5AABoQO8IngkUcnBnEHIAANBg0jteLhdHiyPWyGzUXBBOqQWPAwo5uDMIOQAAaHDX3lGgprm5NxQOZ6F3fFJQyMGdQcgBAECDeu+oe8H+xlq7ptvBkT01teDxQSEHdwYhBwAADTY8d0zJZLtM85Gk/0wx9dQTPBoo5GUQ7TWEIYczAQCvjLh3PLZ6zYupZFZsvXf8/uL4cwo+v35S0DvWYJ5T0KMPOZwJAHhxuL3jda3JW3nu2EuObg9VjTQ4loNHA71jDQR5GaJ3BACA10TQO4q+qn87QnNLKttmnzs2bzc+2gSPBnrHLPS/08AUx5DDmQAAcO17R90shiN6/HjV6TWvmd7xqFbI0zt+GNA71kCQl8FzRwAAaPBD75h9YueMH6+a9zqN3bFxbAabfjRsK+kdnxT0jjUQ5GXQOwIAQIPi71mLJ4jh08RjA6cfOl6TveP0rpEZ0ynAA4LesQaCvAx6RwAAaLDnb4NPJc2PkvtxcWPTj/bj16hV7XVSCZ4I9I41EORl0DsCAECDp+wdCzqPV+kdnxf0jjUQ5GXQOwIAQIOP0zuGH387k1IJngj0jlno74eAKfg9awAAaDDsHbP5MdU7hsr7z5dD9Dp9O2vtJngc0DuCO4OQAwCABpPnjgA8FCjk4M4g5AAAoMFvveOnL79ACCGEEEI45eXz129vf/wVQgghhBBCTXpHCCGEEELoMugdxe+pNDc3I71ASFOsLA8hhBBCCE9i3DuGonfrHZs+ld4RQgghhPBBuNo7Hvu86XPKqf7+rqk2CCGEEEJ4N9Y/s54+dMz2jv1Vnj5CCCGEED4UJ78rY/Z/odhi7/j9xfEnhBBCCCF8XxZ7x7fBp8nOk8LR48zRM04aRwghhBDCB2HbO4oPrKcfW7/ZvaMwaDQFHSSENYojDHEmhBBmGfSOx8sb307Hb1dvn1PTOEK4SB7h40wIIdzLYu84+tD5zXhSKHLusXFsBvmHPoQF0u7gTAgh3Mttzx37Dm+ldxxN8e7+gvDpyL+7cCaEEG7kzs+sm/Fs79g/tjyOkKwhLJCDgzMhhHAvN/SOtR5xxPAqKRvCMvnKB86EEMKNdHvHMF3qBLqldyRHQ7hC87MCiDMhhNBk/e87iqvHhu/ioddJ1wjhOml3cCaEEO7lpHeEED47+ZgVZ0II4Ub+1jt++vILhBBCCCGEU14+f/12BeAZ8Pu3P7y3CeC1QMgBAEADekfwTKCQgzuDkAMAgAZB7yh+o6W5uRnpBbbgJLXgGUEhB3cGIQcAAA3i3jEUrfWO5u9Z97dM7QEvCAo5uDMIOQAAaLDaOx77vOlzSqG819brdNYDPjYo5ODOIOQAAKBB/TPr6UPHbO/YC/D0ETSgkKfAP7rWcQs5nAkAAN8x+V0Z8xmk3yb6veP3F8efANA7ZsHZWcQx5HAmAABcy73jdfBp8vRJYdMajhTyxBGEoHfMguOzCHpHAABo0PaO4gPr6cfW10zv6AhcZa8JXhD0jlncntzzkWsNfe+IMwEAL46gdzxe3vjWlLkl5WN2Jk2D76B3zIKn+ItoekecCQAAxd4xfBh56/nCe039jZLRXOA1Qe+YhfMvOiAgPrPGmQCA18S25459h+f0jv1VPYW4F7wC6B2zoN1ZBL0jAAA02PmZdTOe7R37x5bHEdI0uNI75kG7swh6RwAAaLChd9QdpDO4fhd4EdA7ZkG7swh6RwAAaOD2juHXDfUXELf0jnzHERxB75hC/41kDlQWzd8Gx5kAAFD/+47iqkipfu9IXgY96B3BnUHIAQBAg0nvCMBDgUIO7gxCDgAAGvzWO3768guEEEIIIYRTXj5//fb2x18hhBBCCCHUpHeEEEIIIYQug97xMkZzczPSC5SFs2JZ4ZRaCCGEEEL4nXHvGIqu945+V5rSqYXDWegdIYQQQggLXO0djz2Z7ghr7ZpuB8NBZyJ6RwghhBDCAuufWU9bw/A5n/PQ0XxAOBJzHlVqAyD8SCTIcSaEEG7k5HdlzGeQo6eD/WvdKYobhf7vL44/p/R7TQifnbQ7OBNCCDey2Du+Gd8jbJ419neZzx17ydHtoaqRBmeNEEIIIYTwyLZ3DHu7UZ83bfveko8DR0qmYm/dY8isnRB+SI7+hQZxJoQQ1hj0jsfLu97eOshsS6p7x6NaIU/vCF+cBDnOhBDCXSz2juKDYPG58CjnFnrHY+PYDIZWCbVUAvjhSZDjTAgh3MVtzx37vi3sz6YPHUc39jJmxzkyYzoFhB+GBDnOhBDCXdz5mXUzPu3PnMeQ4samHx3Nq5taYQaEH4YEOc6EEMJd3NA7LraAhRsLOoXBVAL44UmQ40wIIdxFt3cMP18OP3EOVd2hd9TGCIVUAviBqb8fAnEmhBBmWf/7juKq/jLim+xEp+h1+nm81m5CCCGEEMLvnPSOEEIIIYQQ3vhb7/jpyy8QQgghhBBOefn89dsVgGfA79/+8N4mgNcCIQcAAA3oHcEzgUIO7gxCDgAAGgx7x8vlEr5eh6nNEXOMnP7yjWk2eARQyMGdkQq5QtrMJrrtykc3LibMXQnWd2nK5vNcuuLz2o0FheXlvxpSjjqja5o2MKld3ogfekfHyu/W+Nb32HVEexmdI8J95cA8F+gdwZ1R7h37t+ZdoUCTac8uHqMbRzl2pSKkLCksVtcFR3NKbLRHU7dsL0ZhsR7NRSkcIewcppJT4cLsWXnf8gLqzx2bKPQPib6koVU5dopB8PigdwR3xvbecZrlmlx3S7C92jAlplKoWIiv4dQs6rj0dsm0+ehAfcvUn71+0xsFzSlcZAXXIxvNeGpk96UWCVMbspZcZM+zC/XvO/b2mYY6a0jJaIeqc/nCp+JJQe9YBtFeQx9yo9ThZ6TppCKp6vqUeusY4IyfF1emS7UZIyfUnKNL20pl2evGUcg1URR6tRw2vQ2hN7SXhHB23xddqn04EnZiNWtD2RIhtoi2dxShM93+cEmhH7VnzQXX3HGGE8HdQO9YxnomfU00ISeyk+leR8xUPhXTb7UBTq6eCi9GXepev77ourNoUnm9G49ns7rjei+Dan58UQ4bcdfo4GRjeDrRcXzRpY0P9Ywbt69Xm7LkbJO+I3juKPYyNFpf7eGvVisREdNLnpHXwP1B7wjujGPIbclIR3k/HZnl6l3S3XlqUy7NKj/OIryUdenlb8V+yxaXl3YZFOjmqpBZNExPIcRSs58X1dfMJgozFs3zw0nIOOGXReK5Y7ik8MXolpH+RsDx0WherXx6FTw46B1r2J44XgdO77iSkRyxo+ZUPSjseKEC+Qv0NadcmrU55Zbp1KElQsY32zdSmB26dGShvtpYXrNHDIrZhWNHmjf6ULzuzUjtvmmDaUl470lof8/6+EIHtDiTwuKpQC88vWoG+vbDCe4PescVEPAF9L3jKHtki4cvI8pP89ZByphUedueY8sundaggg3m22ON63/eDb3rRsb0r82SWjBGaBB7HVo7ktfzpqC9NBI2YzV1GFOWHPWfF3XxZ9bO4kNPTQ9J6hRpMd+bYvMcM8DjgN5xBQR8AU3vKFJNIb87AmJSp8an5jrOeKw9uh0UWf1direeVy8tLH8azaRiZFoZN+I49ehnM/XIzo2bKC45XgrFzvOqs+nhXGYomjZkLbmO93oj5p9Zj6Y/7txxDdlAOY440Nqmm+qMg4cFveMKCPgCxGfW4q3ISKlEF6bfkXKRpcVID53/RzpTudeEn+R74bBqOBZq/WKxIzud4ji9epMxXapjJrzqx5WP6b3HSZ1dS8mPBgsr8hdytXe8Nm/KpbvM6KE+sz6+7oNptGfOodJipoy/VaN5z3AoOBX0jisg4AvY3jv2SJUlbYADx55ePiwE10zuLSDl0lpuN2uzX4+1pKitTiX1+x4/VrWRI+FyYKcsKcg7BhTCMnVIneOf8qF/nHWwbUT89x2nQR8KXw/r1GJaoSngp6q7eROcDXrHFRDwBdR6Rz2YlXFybyimWz2n++nbRyHsW24ipTOV22/rSjnNmaVXa/aOI1XOoBYz+7N+30WDkg3aUZyYtvnyziUzPKaY6tS21ZKDWNTUdYvn8QjVO5pGhzHhuFWM165mc8pGP4L7gN5xBQR8Af3fdxQFdToSIluG12+8jgtJs8AmvYvE7tTXLLJJPixGveTU7JFwr9npIfy66V+aQrtC10SzfE8N0F4dHaJ1eW15eTlZgcXgX1e7xYARgu87htEjrBnJ38b1AoTA9MZrFKDHSBJXdcyBxwS9YxaXQZEAJvyQczJSf4uTgsLsWrvRv3qUaaJotJbaFM7s2qW9eX6eD307NckU8LepZurUjGnkLG7QA+IiM155vea+Z8NvUafWfOrm1v9PQgDuD3rHLBaTF/iQIUc8gI8KMt598Fvv+OnLLxBCCCGEEE55+fz129sff4UQQgghhFCT3hFCCCGEELoc9o6XyyV8vU5TmyPmGDn9num77wGE8GOwkDaziW678tGNiwlzV4L1XZqy+TyXrvh80Ve+wvLyX40pR53RNU0bmNQub+QPvaNj5XdrfOvL63HEGhmdI8J95cBACHfRyUjTu0KBJtOeXTxGN45y7EpF2OXSrM01XzmbVXPL9mIUFuvF5b8gw85hKrnLpVklI2u372/9uWMThf4h0Zc0ClsVnhZxhCCEsEYzIzlolJjpK5tCxUJ8DadmUcelWZuPDtS3TP3Z6ze9UdBc9pvwwEh+lxlPzey+1CJhakPWkovseXax/n3H3j7TUGcNKRntUHUuX/hUwFcgEX6eV3vH+hnJmaIXvlWRULLw1jHAGT8vxkyXpmwOfeuvQpe2lcqy142jkGuiKPRqOWxGPjlvvF/dRjdqH46EnVjN2lC2ZH0HR2x7RxE6/WDjF70kfz3mgmvuOMOJED4sCfiT/On3LgUxU/lUrNwEhPVP1/XULVlvb7RZjG8xqbzejUe1Wd1xvcef/dT6anlFerryuBbe4sbp6zPm7dWmLDnbpO8Mnjv284U71w/qJWXF9MpFShKZYm9eg/DxSYTfx5l+RjrK++nILFfvku7OU5tyac3mqZeyLr38rdhv2eLy0i6DAt1cFTKLhukp1sePu3OGG1ObKHZ20R4/nISME35ZJp47jjwS7rHQ4ITC1EejeadbtdF3ED4+j8dkb+54QeryUMtIjli/iWY9KGx3oQL5C/Q1p1yatTnllunUoSVm2PhOLuxj+KJxrJAR9jvm6SnWx521LLpxFDPhjGaspnwYrtGP5MUQ0mx/z7oxVwS0OJOpw6ad6/jFDPTthxPCx+fomMCyM0fZI1s8fBkzQ4pEl0p6fnEK3bIxx5ZdKgSyJqXK2W3Jo593Y++6kTH9a7Ok1vy2fdy8ccWH4rVvcMGH5n4J/edFXfyZtbP40FN6nf7I1C8pb9b0Q/gB+C5166OyyY0iT6bar2miMzWvJNt+xmPt0e2giLHFwKsVbz2vXlpY/jSEH5oRbdWKo0YK9c9m6pGdNdtGSraPhwJb/OlserheMxRT++hbIvZ6I+efWY+mP+7ccQ1TQ8VqHejtmW6qMw7hh+Ht1BDtW5xpvhUZKZXowr0bKRdZWozoZY4qQi+fyr0Fh09LTCMcVg3HQq1/epp6O6eWp7bGdKmOmfCqH1frBmwZHx0ZvUe+D1NOSMXqyry+JRvN6Kk+sz6+7vdvdDJTLl6R9LdqlPjOcCiED8VT08erUee6cvEo50ydlkdw7AlLcmiJn3sXHT51aS23m7XZr8daUtRWp5L6fY8fq1PvhcLZoJ0uMzuenajgw+l2TB0o7vIP403YOc462DYy/vuO06DXtmorV0719Op08FRvQvhoJOBPcub0re/zbNdi9NIAACAASURBVBn2DdCtntP99O2jEK4tP7vwLb3jbV0ppzmz9GrN3nFx+SlvhJHT77toUFKBPQrUxXEtLHxlhscUK5uV9aGzKG2SOaNJ1TuaRof7mj0PBcmUT6evIfx4POa4URmANZc6+cf0tlPJ9t74Ni4kzQKb9K7r9LS+FrydckVYjPTCtc2FerxSN/1Lvuv07OHr6YpSOyjCbNf4MVzD1+vLmd61a6KNarcYMGLwfccweqYrcVaYzSZasomP8PyLq40khBCu0MlI/S1OCirnUieFmotqpja1LWZX06W9eX6eD3274rTQmOktNVNTGxeatLhBT8fyes19z4bfok6t+dTNrf+fhBBCCJ+R5WIGIYRvt97x05dfIIQQQgghnPLy+eu3KwDPgN+//eG9TQCvBUIOAAAa0DuCZwKFHNwZhBwAADQY9o6XyyV8XYP4mqeYdzq1Y+T0e6bVNYF3AIUc3BmpkCukTUdsmidXlI9uXEyYuxKs79KUzee5dMXntRsLCsvLfzWkHFU4/o4B5R7m1D39oXd0rPxujW+9XsN0Y7RmR/g2GO4rB+a5QO8I7oxy79i/Ne8KBZpMe3bx8DN2b4xTEcqWFBar64KjOSU22qOpW7YXo7BYj+aiFI4Qdg5TyalwYfasvG95AfXnjk0U6kPin2qdIrVax04xCB4f9I7gztjeO4YthUh0twTbqxX5c6p2uhBfw6lZ1HHp7ZJp82VcX5pbpv7s9ZveKGhO4RIFjDmy0YynRnZfapEwtSFryUX2PLtQ/75jb58w1Fz51PXhFFqtmFoEAXhM0DtmQZwvog+5kUv9jDSdVCTVVM6cZtSpAc74edFlulSbMXJCzTlCbLGy7HXjKOSaKAq9Wg6b0IxRzJw0vjHjaR+OhJ1YzdpQtkSILaLtHUXojHYotE8fMGdcO0VPIXCGE8HdQO9YA2FfRhNyIh2vNx9CZpoPw5FyExDWP12/U7f4ZqSEHQPE+BaTyuvdeEib1R3Xe/zZT62vFswINZw9vmLzSMno9d4ZR2pTlpxt0ncEzx3FNoRG66s99KX+VI8mHekRmWKaVsCDg96xBuK8jGPITXPX6NJI3k9HZrl6l3R3ntqUS7PKj7MIL2Vdevlbsd+yxeWlXQYFurkqZBYN01OcN75ic4PUpo9mXLTEDych44RfFonnjuGSwhf9a38x4a6E5oXzjqw1r4IHB71jDYR9GU7vuJKRHLGj5lQ9KOx7oQL5C/Q1p1yatTnllunUoSVCxjfbN1KYHbp0ZKG+2lhuGjCy56Txkc0FjGImnMs07DjuGNnviB/JW5wwQvt71scXOqDFmcwettpbf6tOOpzg/qB3rIFQL6PvHUfZI1s8fBlRfpq3DlLG+PJn5NiyS4VA1qRshToWwf7n3dC7bmRM/9osqaYBI3tOGh/ZXID20kjYtCR1GFOWHPWfF3XxZ9bO4kNPOZEnQqHPOI1Cx4NhoPf2i3HwsKB3rIFQL6PpHUWqKeR3R0BM6tT41FzHGY+pOEzOjU5dJmqoFW89r15aWP40mknFiLZqdKmG49Sjn83UIztrto2UnD2+YnMDZ9PDGc1QNG3IWnId7/VGzD+zHk1/3MLjGoRk9m3vo+n2TDfVGQcPC3rHGgj1MsRn1jp3hTJXoxfp0+loIm2POdJD5/+RzlTuNeEn+V54Wl9H2hbrcW/n1HLn6k3GdKmOmfCqH1frBpw3PrXZ96GpsBcwd7w2r2/JRjN6qM+sj6/7jRmdzOlSa1uuU5j20fQu8Cygd6yBUC9je+/YI1WWtAEOHHt6+bAQXDO5t4CUS2u53azNfj3WkqK2OqXQ73uydVZ4LxTOBu10mbvGRzanjA/v8gWc4+8fxpuwc5x1sG1E/Pcdp0EfCl8P6xwJmG/L2WE6eKo3wdmgd6yBUC+j1jvqwayMkw9DMd3qOd3PUcxsqhzLTaR0pnL7bV0ppzmz9Gr1a91emINabLrGxhKnQUkF9ihQTxoPR/yr19I/w7KblfXhVOfUJHNGE6p3NI0O908Ebh+gzVXzLKV8amoADw56xyx0DQBT9H/fURTU6UgIp5LtvfE6zrTNApv0LoqTU1+zyCb5sBj1klOzR8K95qnAyBhhqnNpCu0KXROnK/Khw+yM8Wn41ZZTOGuLwb+udosBIwTfdwyjR1gzkvc1mHeFAT3IV5fpVR1e4DFB7wjuDD/knIzU3+KkoDC71m70rx5ljpJiLbUpnNm1S3vz/Dwf+nZqkingb1PN1KkZ08hZ3KCnQ3m95r5nw29Rp9Z86ubW/09CAO4PekdwZ3zIkCsXMwAAuN56x09ffoEQQgghhHDKy+ev397++CuEEEIIIYSa9I4QQgghhNDlsHe8XC7h63Wa2gqTOrfsXQuEEN5YSJu1rHVeFtXaRshquJufUzaf5+fykrcXLKGwvPwHZGot53U7NeWLNjThfdIm/tA7Tn+d52ZTOXfscp958s/YGAghDNnklo2dR5NpzfS7N9eNtI2y8UqZ2OXnrM01Bzo7WHPL9moVVvDF5T8mL3b/VDu2e80YifmWj8LppE2sP3dsAs4/D/qSRq/HEU6phRDCGp0iNE1Hffp6GyTkXv+puS6l9tS86vg5a/PRq/qWqZN7/aY3CprLfhMeGMnvMuNsZl1X26ysw6fKL9G5duTLM66w/n3Hfp0rC94iM42M80IEQvgKFHXoInuLXkzP0gtfuiZy8W1h7f74ednV9HPK5sUaoevdSr+1142jOGxCK/Tqxlga7VTZS6lljoSdcFrfPh0qoxemcrGt289j2zuKKOkHG/+GmxTuh94h03GhJSOF/uwQQhhylKnCt6YSU2ZaJzZaKKzyU+h5WTd1r2mAGN9iUnm9G8tTs7rjei+DEn98sSuWLlF93x6o09dneNjUvCtawt0U27p3pcFzx34CvdlOKPh+MZVo8/QZyOqHEMI3mUBEPzSqWNOGxlFiqp3qP9tXG9WWS7Jv89R1WT9f/lbFt+x7eWmXQa1srgqZRcP0FLtWndqXk8JJ3368Oo0lEVFTzcLJi0w8dxyZGFqmF6aPytR3zYi2pBnX+wHhRyLRfqpvm9fT/OMrHF0y60p2asc2B7VV+5pTfs7anPLVdOrQEsc/KScX9jF80ThWyAj7HfN8J/SuqO2O2OJUOBWWqXdQKHEWG8qE+hdjZsT296xTK+83NQwysVsF7/RXhZGn+g7Cx+fxxHEQdrl0lLibF+Hbkc7C1X4iB+VVF1a014ZFP08LU80bztv+GL7LkexdNzJmWtZ7y52ddbZsNLXvK72QqU+EsLnM7JJ7/eWE0N97UqTFn1mnNngaZOVlpNwnPH5eFoPwwfmOhepjM6yd09emquaqqVmbZBqjzTimTZ1IRcgtxmGtM9Dz6qWFNVFD+KEZ0VatOGqkUP9sph7ZWbMtG7Ej86azTPdlGiG7nJ/ym7lesZBpvO3i/DPr0cTHkDruirngUKEDoc0x1d9FCD8Aa8kX+r4N34p8mEp04cb5Cc0ccQJDF4XRRKLIbXH7tO40wmEpcSzU+qfnq7dzarnvK3MHe21OmO2tnlqJjqItM2oBc1M2LllshxAWx+qMExdSfWYtDBKH0HGNuRjzUE09fnZwQPiwXE++sHGm8zaVZ1LlTRvgoFfiNyiNklFc6eUvxmHKz9miM5LUC/HNEEU2dKlTXs0dnGrTq3aEs5E83Z319JUyyTm2vrenLnVcUQ7FlBMKjP++4zS+9ZpN68sZczSXGQSpvYfwqbmefGHjTPOtGMzKOLk3FMsWHseGsH0UwrXpst7Y0jve1pX1ZKoHcm7XvUvZpammpO9iG4y8Z9rgNKaj9DWaqzcyxIo//f7B1Dw1qRHQs5tHfp2qdzSNSIVCalXT85MNguMe+BEA4ZPyFuS3n8T8FpeOaud0ZKSzJlC+sSBzXHVY2kOFTvEubEHKP2GFCheozR4Jhx6Y1ia/mPqXfNc5tXLkxuykU2+HDj+KNW9DDdMl+wKL8amVLB7J7HK2rCVk8H3HMFCmjhbj2noh4IyHh7xfxWgWPwQhhFDwmPFGGam/xUlBYXat3ZgV0Ctt7DH1L6Zc089+mTAdvsvP/t7VTE1tXGjS4gbdh6aR5tZkI6Qwqa9NiGUj7Tz/1/9PQgghhBDCe7Lc0sGN/K13/PTlFwghhBBCCKe8fP767QrAM+D3b394bxPAa4GQAwCABvSO4JlAIQd3BiEHAAANhr3j5XIJX6/D1FaY1Lll71rAnUEhB3dGKuQKabOWtc7LolrbCFkN65aEr8WMjs3n+bm85O0FSygsL/8BkVrLed1OTfmiDU14n7SJP/SO4pg1R66cO/yVTDPCSZrBI4PeEdwZ5d6xf2veFQo0mdZMv3tz3UjbKBuvlImUJQUPmBVk4w7eXqTcsr1ahRV8NNdT18qL3T/Vju1eM0ZivuWjcDppE+vPHZuA88+DvqTR63GEU2rBI4PeEdwZ23vHaTrq09d1kJB7/afmupTaU/Oq4+fbJdPmo1f1LVMn9/pNbxQ0p3CRZV2PbDTjbGRdV9ss05LpSH9Jb5O+lJpxBfXvO/brXFnwFplpZJwXIuA+oHcEd0YTcqIOXWRv0YsJiKSqk1jqbRZm6d0yl2OG0xxk24Wax3S9W+m39rpxFIdNaIVe3RVLI2+seKmfYvq6H3TCacUSYUNvyVR4dHW0rdvPY9s7iiiZ7rTeJN8vpuNCS6ZBeUZ8gLuB3hHcGceQ0+XTz1cFmWmd2GihsMpPoedl3dS9pgFifItJ5fVuLE/N6o7rPf7sp9ZXszaIKRaVh7ePXu+ayzQjNWMh6sLwbjZu70qD5479BOHc/aDepKxYeDWEtsQZB88CekdwZ5i9o+iHRhVr2tA4Sky1U/3bcdJcWT9nlR9nEa7L+vnytyq+Zd/LS7sMamVzVcgsGqanWFR+vN3fl5PCSd9+vDqNJRFRU83XsZMXkXjuODIxtExo0Mod3zUj2pJmXO8HeHDQO6ZwC3ICvoxRyPk52nS7EBMZTG/rrh0XaXlkhr9qX3PKz1mbU76aTh1aImR8s30jhdmhS0cW6quN5TV7wvGbwuzaR9saLsEMp+P41JLG7HAHhRJnpaFMqH8xZkZof8/6+GK68n5HnSALYy40Tq85tCQMspN8B+4PescswhMKfPQhNyoe2SLky5gZcpSxRW70kY0ip4gsWpL1sxDImpSqcbclj37eDb3rRsZky/o13zs6UV1LX3ohI2EznBaX6UTpdAptWzjj9kiLP7N2Vht6XIegP6LHw6vC4+dlMXBn0Dtmkc1coIHz3LEfSRW8aaIzNa8k2yn6tKkTqahYi0FY6wz0vHppYU3UaCYVI9qq0aUajlOPfjZTj+zcuIlivDapsy+hTjNaUkgtYbQdWqe+d6qthvln1qOJjyF13JWpiSJoHIR6tMdPin5wf9A7ZkHML0KEnPCtyIepRBfmND+hmSNOVOiiMJpIFLkyTD+HwmEpcSzU+sViR3ZOLXeu3mRMl+pACq+eUT2dzdo16fSWVDgV4C/Bjw1xrM44cSHUZ9bCIHEIU1u1IumfxrODA9wN9I5ZbMz4r4na71mn8kw5Z+q0PEKvxG9QGiWjcqWXvxiEKT+HwqkpxL2FYi+K7PG1U8uOg+bS/ADWRo6EV6LdCZVC5KQOl3NsfW+HerKBWg5FZ9IVxH/fcRrfI7NGqWQkr+HomXq8HOLgAUHvmMV68n1xLP6NnpVqOhVI1X6hKmVk2D4K4dp0jiWOzlTveFtX1pPTWcxqFUpOLdHyjs3hSN/FNuhvz0bytEUW4yM/OBAmiUE9tanE8Vv/1g9j88ivQ/WOphHhNmdDPysZWjjdquMe+BEAHgf0jik0uXKU9IFA4W+Di5EQ2Yq7fmNB5rjqJueLPOwU7yx8P4fWjiSnZo+Ee81TgZExwlTn0hTaFc0am9dOtXUMCL0ajo9krpGHxYxZgcX41Eoc5TpQU/duWUuI4PuOYaAIU0by4UgqcTg2hIe8X8Vo3pQ94N1B7wjuDD/kmoI3KpPNLU4KKufSdQFxV5+HTf2LKdf0s18mHAu1zSk/+3tXM3VqxjScFjfoPjCNNLcmGyGFSX1tQiwbac50NdT/T0IA7g96R3BnEHIAPBTKLR3YiN96x09ffoEQQgghhHDKy+ev397++CuEEEIIIYSa9I4QQgghhNDlsHe8XC7h6xrFF1HFvNmpHeH1tUAIYchC2qxlrY3KU6sz0/hUw938nLL5PD+Xl7y9YAmF5eU/IFNr2dvtrCtftKEJ75M28YfeURyz5shlc8dIYLrB/o132xgIIQxppi99VyjQZFoz/e7NddlsnC0TZ/h5sYJs3MGaW7ZXq7CCLy7/MXk0PuXk806NGag1y0fhdNIm1p87NgGnz4N/gHWK7K0Kj2IvqXGGZyGEr0Yn703T0SjR9WpF/jwj16XUnppXHT9nbb6Mi05zy9TJvX7TGwXNZb8JD4zkd5lxNrOuq21W1uFT5ZfoXDvy5RlXWP++Y79OseDaAZuGsumj0MLzfAoh/KgUdeiYZ0Sic9KOSKqpnLk345mld8tcpnOmzUG2Xah5TBf4ae9S07y4gyK0Qq/uiiW9WTUvpZY5EnbCaX37dKiMXpjKxbZuP49t7yiipB9s/DvdJH3JCc3RoN7yUGBjfEAIX4E6R5mZxBEzS85UrGahsMpPoedl3dS9pgFifItJ5fVuLE/N6o7rvQxK/PHFllgSSprpFlc6fX2Gh03Nu6Il3E2xrXtXGjx37CcI5+4Hp5vkXOoPsL/3Ix9NxyGEcEpd+VKlwmloHCWm2qn+s321UW25JPs2T12X9fPlb1V8y76Xl3YZ1MrmqpBZNExPsYupfTkpnPTtx6vTWBIRNdV8npMTzx1HJoaWpVyj5wp9cbxRW9KM6/2A8EOSaD/Dpc3raf7xFY4umXUlO7Vjm4Paqn3NKT9nbU75ajp1aInjn5STC/sYvmgcK2SE/QXzRlu5qHm0reESzHBKGXPTLHZQKHEWG8qE+hdjZsT296xTK++j2QmyXW9DS8IDdpLvIHwKnp1EXo2j4pEtQr6MKGO9YVOUV11Y0V4bFv0sBLImZcvWsTL2P+/G3nUjY7Jl/bjMgg+baNE2FzQLDdlwWlmmswrnjGjbwhm3R1r8mbWz2tDjTpCJyOiTS6NQxIHw+HlZDMIHZzZzwZpj38bZyakW+qqpWZtkGqPNOKZNnUhFxVoMwpSfzY3QS+sXOKomvXDvh2ZEW7XiqJFC/bOZemTnxk28+VPMnprU2ZdphOxyfmoJo+3QOvW9U201zj+zHk183N3jrgjJ7Nt+1/U2O6b6uwjhByAx/y6+1fnQwfH20UTTzTVHnKjQRWE00bRaL7pd+DkU7j3s7OxUv1/sxQvTklDGdKkOpPDqGdXTbxLWJ53ekgqn9cXWgsRZ1HknLqT6zFoYJA6hHxYpz4psNfX42cEB4cNyY8aHfu5K5ZlUedMGOOiV+A1Ko2RUrvTyF4Mw5edQuLAjeiG+GaLIhi51zq+5g1NtetWOcDnaR8rX01fqcDnH1vf21KWOq8uhuOi3KeO/7ziNb73mVICGb2tzmUGQ2nsIn51OQoQpTzpvfZ+nylvKgGzhcWwI20chXJsu640tveNtXVlPTmcxq1UouWsHp3bqWnzpMPKev3dOjzjqRkZ+cLDiT79/MDVPTWoE9OzmkV+n6h1NI0ZbKxzRbLO/Mc1c2SA4KvcjAMJnJ9G+15Oj2jkdGemsCZRvLMgcV+3nYad4F7Yg5Z+wQoUL1GaPhEMPTGuTX0z9S77rnFo5cmN20t4zwqujkzX18HTJvsBifGoli0cyu5wtawkZfN8xDJSpo7PnueDxMO7DQ96vYhRqfghCCKHgLeeIjNTf4qSgUTUt3JgV0Ctt7DH1L6Zc089+mTAdvsvP/t7VTE1tXGjS4gbdh6aR5tZkI6Qwqa9NiGUj7Tz/1/9PQgghhBDCe7Lc0sGN/K13/PTlFwghhBBCCKe8fP767QrAM+D3b394bxPAa4GQAwCABvSO4JlAIQd3BiEHAAANhr3j5XIJX29B813ULVMLneJrsIsLAXcGhRzcGamQK+QuR0wnyUXlPtYT6a7E6/s5ZfN5fi4v+Yzi61+iRKZ8UmtdnhQ/9I7imDVHLpU7sonG2YCsAaG2D7+7Hw/0juDOKPeO/VvzrlCgSXRm9tub4kQ2Dgezmb9sScEDI5vN27Nio43zi9cuXKIKPpqLEnlN/kNFvP1gqD93bALOPw/TS83Ujlp/R/04AA8IekdwZ2zvHcPuQSS6MCuO9PtqC0ipPTW7On6+XTJtPnpV3zJ1cq/f9EZBcwoXWf70yEYzngXZLaht+pOi/n3HS5e/wrhMHYbLj1ny+Lb56evU8oWFg3cEvSO4M/qQG2UPnfR6MYHLOKleZH1Kvc1idHs4fl52Nf2szRh5puYxIbZYcfa6cRSHTWiFXt0VS2KnTh2vmTp93Q86YWnOft4hWkfbO4oo6Qcbv0yd61waqQ1tcHSCjwR6R3BnNCEXprvRSAhHzFQ+FdtV72+3j5ASXiyKqXtNA8T4FpPK691Y2prVHdcbltewBC8a1hhwt9c1pDRv3KlTde5C8NyxN7eJodGgcK5/gMN7w0uOTiEzsgE8MugdwZ1xDDmRK0QmGVWaVC4aKTHV3j/XnTRX1s9Z5cdZhOuyfr78rX5t2ffy0i6Dqn0ZV97p1YIZoynOG68htb9nhOWu3T8DieeODUZRGN4yuhS+FoMpPQVJ8OCgd0zhltGmJQqM4PSOo8Ks7wqV6Evv2Hk4KEyd0pzyc9bmlK+mU4eWCBnfbN9IYXbo0pGF+mpjuWnAyJ4zxm+GZX04Co/RLNq2XrnvrjBcd0VFDe3vWR9f6NgN7Q6DTKgK19zMMtLs60zNDh4Z9I5ZhCcU+Oh7R5Fnmhfh2xBaZnS1n8jB1JjpXP6Kzki8ZT8LgaxJeupwX64/VrFLV9HugN51I2P611NvOzvbqA238qTxbAD32vTt2bBMuUvovHMI3RB/Zu0sfrRboby/B2EciLlMnaYkeHDQO2aRra+gQdM7igRSzjNaQEzqlPPUXFMzbghH+ol07ShbMn3tC9wuiaWFNVGjmVSMaKtGl2o4Tj362Uw9snM9kPoZzxuvGe/sb6hz9DqLfnV79a9g/pn11PrGmyO3OmfMj2NTZ1YSPDjoHbO4lJImuEF8Zi3einwo0lGfmvpkKJSHczkjTlT0qwvXK2SEcAqmn0NhM/k7fjuOi8WO7Jxa7ly9yZgu1YEUXvWDrQBn17aMrxs/vSUVlv6ko9B69x5GfWZ9fN27fnQIUy52BHSGMnUWJMEDgt4xizMy/kthe+/Yo5wzdVoeoVfiNyiNElHYhOXrBdWcaCScmkLc28/uNzEjwxqXOufX7yH8ANZGjoSzO5st6OXx9TSYOqTO8XfctdH+7Yj/vuM0vkPhaxf3t8FsLhtNejTM1JmdHTwy6B2zeMCk81yo9Y56MCtjlkydS4WqlJFN5tQKy9M5ljg6nRJ2FLjMuuGpZmGec8vIAEf/FNrOMJxEze1vzwbS3caFzMifDkKd00E99ej2frrRRtwHqnd0zs/V26qpkqlCfa/vvvdyNNgCescsdLoHU/R/31HUzulIiFQJ2XJjQea46iZFiyLqFN0ssnVBFJTGTm32SLjXPBUYGePUvnKYaSXXbuOa19MV+TaMjs954/5WCrOzAutxfjOvsXzXXqwg+L5jGChHgXBEjDvQU1x/3GNfZ2F28Migd8yC8F6EH3LTnBPe4qSgXqB8Y1ZA3HUxarA/WJhd+7k3z0/+ocOnJpkC/t7VTJ2aMQ2nxQ16QIgVmYs1tzgbaTU02t5lv+r/JyEA9we9YwpnpK1XAyEHwFNjlAafOjee1JX6+K13/PTlFwghhBBCCKe8fP767e2Pv0IIIYQQQqhJ7wghhBBCCF0Oe8fL5RK+rtHU0Hy3NBxZ0b9lLb2qms7+ro22QQjvz0LadMTKuWJvShG/B5DVcDc/p2w+z8/lJW8vCqkySklK+WRv11RTbgb2On/oHcUxa45cNnc0yx7d2HtnxV/hJS05XXioqrYxYo9NAyCED0U/26TE+iRgZoa9SWOkbZTKzstgqayesrnmQGcHa27ZnvbDErO4/I/NoxNSm3Xe6csG/Bn7WH/u2AScPg8jbVOxFX9lnZ519zQd6OyQ3WOOMYQPTqd4hOlC5E+RCcNib6qtrc5Xe2q+cvyctfki8/nxlqmTe/2mNwqay34THhjJ7zLjWZjdgtqmZzdOK18JvxTr33e8dPkrjMve4yJ8Q+F+w9Spinb3Ig+AGQd6+aFwLyNm19OdtP0QwixHeUMnqF5MT9ELh6lm5W1h4f74efnK9HPK5lEeNlchxJxaU9O8uIMitEKv7oqlkTe0l4SwUHWqu0bCTliuWOLYcJ4lN7a9o4iS6U4L56b2wHFcaElNz+jG6aTCOaHMdJt7x47cCyF8F4rzuCWbpZRPxfTbwtpHSAkv1rDUvaYBYnyLSeX1bkz7zeqO671EVewia1zNMD2FUO7PPtK5aO3o9Rk7ZWr2nbbRJzcGzx0dC6ZmiVVN9yAlKULf2QMnBMNLzYw6mJxQm56i80ITQujQyQnmXU5D4ygx1U7139NXi2pTfq7ZPHVd1s+3erFl38tLu3TV5DjerzG8d8UwPYUQM2ffG3Wp/T3JJH27CMvQvRv9k3juODI6NKt5ffTsVEwjNCM0W3jZ8aAOBbFnx5Waaxe7e8auw5eiPkEw5UkxPj3CNeWNZicrZqd2bMsmZ3/VvuaUn7M2p3w1nTq0xPFPysmFfQxfNI4VMsL+gnmhfDjRaNDfxIIbR5q1hamNdgzQkSCmG233Fra/Z52yeLRz/WJGASrcakaD45owyqeu0TJOfIRWTbfcDBEIHZqJDPrOHJWfbPHwZZw8+RalDpHAa2vPrmivDYt+dkpJwRvOJRG63AAAEJlJREFU274C9tXwDhxVzN6Y/vXU29mddTSIvQ6tHZ3QWhrUDpn6Vs+16C4nJ4y2ewvjz6wdK0NrRiHo70Ho0NGgr3M6Mt2qwkYKFwkN5jiEDmtJE46caRakaaXxN0VM6pTz1FxTM45VuR/pJ9KJsWyJ72dzI/TSwpqoIfzQjGirVhw1Uqh/NlOP7Ny4ic6WTc/IcV+mt5vGO/urzd64idMl9Baaltc4/8y6Hwl3S++x49bpwsQs4u3I8qkTzWB1Vj31iRA2Dw+EIfdm/BdnIe1MU7wuTmGyMtOgP+JEhS4KqTS7GISmn0Nhs4g6fuuXKXT2dpqJ3dwa06U6kMKrfrDVdnDqLmfXstWzYLxvs5h3heYStBkb7VGfWR9f93aPtnOaLETG6dWGE4nAcpw1PeeOl7XlvfF+KExXBKFPM+PAdWfqrO2r9QWmWUhkyOYux8hRUhrl2JHli0GY8nMoXNgRvRDfjFCyfz1SODLDXJofwFPvrQRS1jDf8uy4z9QhdY6/v2uOQ1Lu3cL47ztO41u7zE8l4pz0qvQ2FDyuHZq6amaWrIaUAIQ9m4AninY5c/pWDGZlzPzmFJh1I8P2UQjXpst6Y0vveFtX1pPTWXQ5c2ro+g5O7ZxW5wYj7/l75/d2G3vHJnpH/nSwsi+Ouwqaw/hZPHEhVe+YzTsiLvXWCg3myXcSh15RNlbW9yar4Yzth6/AY/QSRbuc6aTHldrgCGxJGqZMGEXTQjVNpLUtSPlnVH36BWqzR8KhB6bpPTRGmOpc8l2nZw9fr5e80LHhJXHXVH463vjBXMhUbGVfCvOK8ZMsaRh83zEMlKmDtLlC53GpfVSN4qzgmuwepLSllIwiOyUPYYFE0dm+vYwR3uIc7TC71m7MCuiVNvaY+heD0PRzb565KSOH7/Kzv3c1U1MbF5q0uEGPz2Y7srdo36YirTCp1nbGiQtZ/z8JIYTPxZUsBiGEH4DrLR18u/WOn778AiGEEEII4ZSXz1+/XQF4Bvz+7Q/vbQJ4LRByAADQgN4RPBMo5ODOIOQAAKDBsHe8XC7h6xpMDc0XEcKRqc5Fa2+3+3qmkr3AuktfExRycGekQq6QNh2xcgLZm2fE7wFkNaxbEr4WMzo2n+fn8pK3VwqhkDrVI+WTvV2Tac974YfeURyz5shlc0fj09GNvev1Zpgj0+WEGvwzNpLsVTnKgQC9I7gzyr1j/9a8KxRo8pWZfvfmmWmiawazZaJsScEDI5vN27Nio42bumV7pbgV1jCozp79GXF0QmqztnjvDJ1bUH/u2AScPg8jbVMx34yRgJDXAvqQm/MeV5E1FfSgdwR3xvbeMUws01QTZo+w2JtqC0ipPTXFOX6+XTJtvsjMf7xl6uRev+mNguYULrIG6ZGNZjwLsltQ23THjO0611H/vuOly1/hCnuPC0eEwqMNqx0t82pvqtAzskHYZloLGtA7gjujD7nRyR0lvUbYOfKXcVLt02D5bRaj28Px8zKb6WdtxsgzNY/pSrGS7fe6cRSHTWiNytkuw0YBE3pJe08I1xw+Uj49wqmwXDFjr/Iy2t5RRMl0R4VzU3vQwwkaU6d5NVxyzbZ+g0OPAQf0juDOaEJOHN6VbDaVMXOgLvDrNWyElPBiwUvdaxogxreYVF7vxhrRl6HbyCWqdxdZDWuGjXZfTy0m3RvhQvno9UlTT+2557whgueOYntC9+mr+pJetpYc3evr7C81h8TZFW1YeDJT+sER9I7gzjiGnJM9wksjed3QOEpMtVP923HSXFk/Z5UfZxGuy/r5VgK27Ht5aZdBDWquCpktho38M5paiG20qkdqf88LS6Fq73pTSDx3bDCKwvD10bNTMQ1tlRh37gpDUxxvbU/oInFWwRT0jikcQ1eEMRBwesfmODv5c6REX5pmRV9nCtnk7E+d0pzyc9bmlK+mU4eWCBnfbN9IYXbo0pGF+mpjecqMlEBowGiwCZvb25QbR+GhLUlttGPG1IB3Qft71scXOnbDaB5t5yhAhVsdmcLpSl0VwuHJ8WcMHQWmoHcsoDm272vM06HvHUd5Jls8fBkzt4iUaKZH0wZ/RXttaGbP+jmVz1Oqpm+PCb//eTf0rhsZ07+eetvf2Wy095pFDIhVZNOgdshI2AzLFXfdOWxCxJ9ZO4sPPTUKQX8PQoeupxsxo7iayjUjs8OM+S6J4wOA3rEAwmwFTe8o0leq0oxuDK+ams2kpI3RZhxT2Si5HSfStaNsyfS1L3C7JJYW1kSNZlIxoq0aXarhOPXoZzP1yM4V22pL1ub5t/hw9nc61/omjg7X+2L+mfUoBRw37+jNsltHW+II+K70Q00Ij7yh1+54FWjQOxZAmK1AfGYt3op8OG07+nQ6mmiar8wRJ0J0+qqlxBpMP4fCuvwLC7X+aT7v7Zxa7ly9yZgu1YEUXvWDzUe5jh+NcXZTh2gKvm1Xe3Nr8z5I86A+sz6+7uNmtG3TZCG2s1er48NUOzXPtEcExGg7xV3vvvfPCHrHAoi0FWzvHXukypI2wEGvxDRylAlFZp6WgwJSfjbrgrhL3NvPPjUjlOxfp6qGuYNTbX6FHQnXzPAHp/viHMkaUofUOf7+uQtH3j2rx3/fcRrfofB1vCp9EsR05gEbadbWTq+aIT710ihlC0tACHrHAoi0FdR6Rz2YlTGzmZNk1o0M20chXJvOscTRmeoebuvKetIpAeYt085gxaXazml1btDfXu4dR5F8du84srlfbAht22hQT61vT8XzqVC9YzbviFXpUBAasgesUZWNgEI0ONE8Wsv77v0zgt4xBZHpgIn+7zuO/GkmzB6FErJ4Y0HmuOo+zY4UTlNuAb6fRX3pJadmj4R7zVOBkTHCVOfSFNoVo1I43WUf2qXTS0KbGBSx50fjVGxlX0ydZ0xRRvB9xzBQjgLhiF6V0Kn3ONx1M+YKmG6Vlm/Gw0i9Rp4BJugdwZ3hh1yYsnRqMrNWmF1rN2YFxF19Hjb1b8nSUz/rMqEdGDp8apIp4O9dzdSpGdNwWtyg54K5WHOLs5G2bud7bVb9/yQE4P6gdwR3BiEHwIfElpbuZfFb7/jpyy8QQgghhBBOefn89dvbH3+FEEIIIYRQk94RQgghhBC6HPaOl8slfF2jqaH5bmk4smjAVEkj4Ey67h8I4bNwdN6zeaCWY9832/SzZzOqEOux13U1G1KlZ71UlRdYK1W7lJeXfEY8+1vgl3vfdSKKtsTGg/CH3nG65tvKs+5oTsLoxv7AjI5QdntuIylTQzOmt0AIPzZFhikrMTU4GczMivdZeHld4saa68q+DcdP8nB2gX5pyzo5JXY0I+WWjXvXT6ctWQm57OD29b47688dm5D1N0lo7i9NzTD3YxrZoxPYj4caUqcFQviM3Hv2RfZLTXpnDzgjBS85I1nXbdxfxxXn+VnPdTEecLx5Jay8g6Y3CpprHgvHxeupDaH+0eD21T0g6993vBziTGxM77XR/o2EHafr/Wgs1EHWm+S7AkIIb3RKUba6vFe2qVVE31rhol2uK9ggxs/biNoCU0Uwuwo974r/d7nRWWAv43ijX6DeF+f1B2DbO95c0zu0H2y8Jty06M2pWOrY6AQhgmMUWP5CIIRPTZ0TzBzYv81OKjLS2cufjkzNXtR83qpTfhbCi1tj3js14PJjNIaG+XNtsfm83bz8WL5D5dMYE8ZcxkfblDwvbt+FwXNH4d/QEfrqijdrkv0lHU9a1S4LIYQfgGF+KOTAUbpYKdJOM7GYpqbVd7pGf+Gj28uu28uTpisv0HHgMVB1YGSj6HYQslG3y43hErRXUzZfxkd7lyuei4nnjqGDwhfhtvliGmK3xC42g0Khs/a3Qyz2S3j3TYXwyI+Xtt7Xmf3bMLmNbtS36GSVyopTewqanZF+jY5J/lym67LbmvWGOV1Kc3mBjqtT/tH39m99/6ScfB7FXMKZl3Fgh7ePXn8Atr9n3bhJR3m/2aFnbzL9VWfzHI/7e6mFU8sR+j9YlMDn5QdOXu/lzz4fNplT70Iz4ment0FGEtNNDSssP7U0vzlwNK+4LrU0v+ik1pi1JFW59CqyJk1rXPO2L/FmrG7kaC/6TdG2heNHDc4hXd+CB2f8mbUTsiJYnZGR5vDgTU9j6qqOGD/CIHx8Er2n+rNJETpVjgbNAjPtDwqS/qodZBeuxx3JjbW5X4uzutQafUuyCwzFmkGxtH6B/l73fmhGTLPX2S9BzyVccVzjaMnCDN97z8v5Z9b9SOO+3tF6U8VrZ0tGl/SNU+HQ/tHaU7ND+L78SAnr3RkmE5H9nJRlVlkzNYkid+cYmJqnx09ynWPtqA728qk1FvxmLjB8698y9fa0FPaTOmaYvirs4PTtdMnOpjiu8G98LqrPrEfrf5P/ICv3jqFaMdF0UnMW5+CtLArCByGRucWHYZoKPWymrGmVHSVhrTaUWYyBlMLeV6M07g9mXXczI7uzwvPTeTc62Vxgatzfx3726VzTAlo4MrUdnAZe1gZzf0euWIyKR2P89x2n2699mt0kMZ25YeZepoTF1FPbPliUwOeln/Jg1p/6rS8pBnUfM9Vptgi1tdfGC4M112VXfZyud7tp27qTszqzDeK0Rocj0zSig9NpEmrLFzKp02Eu0LEk1T49L1XvaOYdv9kajWd7x4uHqTEhnbVPZT5eoMAnZXgi4Io/zbciI/U3hiO9gOgGHGs3Lty5ag6ONOuqsWhb6MabM5upU7u8ftYKLppe6muirpjTOK9tiiiRzqWU38phk7VcSx7fbjyP787g+47haZlugN4YofPo0D6UtxzIaQyN7JmudG/KgBA+OPtkFb419QQFfKwnlV72ZiRHz7Q2hyY52Ti8xXRdzQOjVG96ZtHt5gJHszj7Pt2s7Ip6Xzm3TGM+5UzhsVB/OBKG0G2w4IfC7jwF6/8nIYQQQgghfDX+1jt++vILhBBCCCGEU14+f/12BeAZ8Pu3P7y3CeC1QMgBAEADekfwTKCQgzuDkAMAgAZx73i5XKYj4fhIDIAteKlC7h/D/pJ5ElMH9jVP90uFHAAAOKB3BM+ElyrkZ/eO32VSXeYLHvCXCjkAAHDQ9o7T33Jv7m8qSv8CgI14kUKePYbX/Ek8jk9Pa0r4g+FFQg4AAHwsPXccFapReQNgES9VyAuP/52T6A9mzfiQ6EOO/AYAeHHs7B2PD0XIreAM0DtqSX0Sj01P+CCz74pGzy9f54A3IcdHKwAAMOwdpx+THYtTX6hIrOAMvFrvOD2G19NOougjRwIfEseQe9kGGgAAjig+dxzVJ3pHcCperXc0R+5zEl/zUNM7AgBAg/pzxyu9I7g7Xq13dI7hNXMSe21af2jDizxx/A56RwAAaHDK78qM5AFYxKv1jtORZtzpHZvX/UjNto8KekcAAGjA71mDZwK9o5acnsQtveNLnW56RwAAaPBD7yg+nwo/q+JxI7gzXqF3zB7Da+YkrveOr3bG6R0BAKDB5ueO01sAWMEr9I43rDx3HN3VN6DT3nEk/CLgb/QAAMAN/+yff/5n//xz0Ds6TyyaEXpHcB+8Tu/oH8NrsndsXt9+9o8zez0veKj52+AAAHBD3DtOi8fo7fRjNQDW8SK9Y+oYXtdOYvacvtrRfpGQAwAAje9d4/C5IwAPCwo5uDMIOQAAuHa94/8PmqZpnMYXsOoAAAAASUVORK5CYII=" alt="" />