Exemple #1
0
        public static void encrypt(global::haxe.io.Bytes src, global::haxe.io.Bytes iv, int blockSize, global::haxe.lang.Function encryptBlock)
        {
                        #line 9 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
            global::haxe.io.Bytes vector = iv.sub(0, iv.length);
            int i = 0;
                        #line 11 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
            int len = src.length;
            while ((i < len))
            {
                                #line 14 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                {
                                        #line 14 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                    int _g = 0;
                                        #line 14 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                    int _g1 = blockSize;
                                        #line 14 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                    while ((_g < _g1))
                    {
                                                #line 14 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                        int j = _g++;
                                                #line 16 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                        src.b[(i + j)] = ((byte)((((int)(((byte)(src.b[(i + j)])))) ^ ((int)(((byte)(vector.b[j])))))));
                    }
                }

                                #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                encryptBlock.__hx_invoke4_o(default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined, default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined);
                                #line 20 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                vector = src.sub(i, blockSize);
                i     += blockSize;
            }
        }
Exemple #2
0
 public static void decrypt(global::haxe.io.Bytes src, int blockSize, global::haxe.lang.Function decryptBlock)
 {
                 #line 20 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\ECB.hx"
     int i   = 0;
     int len = src.length;
                 #line 22 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\ECB.hx"
     while ((i < len))
     {
                         #line 24 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\ECB.hx"
         decryptBlock.__hx_invoke4_o(default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined, default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined);
         i += blockSize;
     }
 }
Exemple #3
0
        public static void encrypt(global::haxe.io.Bytes src, global::haxe.io.Bytes iv, int blockSize, global::haxe.lang.Function encryptBlock)
        {
            unchecked {
                                #line 9 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                global::haxe.io.Bytes vector = null;
                global::haxe.io.Bytes vkey   = iv.sub(0, iv.length);
                                #line 11 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                int i   = 0;
                int len = src.length;
                                #line 13 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                while ((i < len))
                {
                                        #line 15 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                    vector = vkey.sub(0, vkey.length);
                    encryptBlock.__hx_invoke4_o(default(double), vector, ((double)(0)), global::haxe.lang.Runtime.undefined, default(double), vector, ((double)(0)), global::haxe.lang.Runtime.undefined);
                                        #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                    int block = ((((i + blockSize) > len)) ? ((len - i)) : (blockSize));
                    {
                                                #line 19 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                        int _g = 0;
                                                #line 19 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                        int _g1 = block;
                                                #line 19 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                        while ((_g < _g1))
                        {
                                                        #line 19 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                            int j = _g++;
                                                        #line 21 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                            src.b[(i + j)] = ((byte)((((int)(((byte)(src.b[(i + j)])))) ^ ((int)(((byte)(vector.b[j])))))));
                        }
                    }

                                        #line 24 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                    int j1 = blockSize;
                    while ((j1-- >= 0))
                    {
                                                #line 26 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                        vkey.b[j1] = ((byte)((((int)(((byte)(vkey.b[j1])))) + 1)));
                        if ((((int)(((byte)(vkey.b[j1])))) != 0))
                        {
                                                        #line 27 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                            break;
                        }
                    }

                                        #line 30 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CTR.hx"
                    i += blockSize;
                }
            }
                        #line default
        }
Exemple #4
0
        public static void decrypt(global::haxe.io.Bytes src, global::haxe.io.Bytes iv, int blockSize, global::haxe.lang.Function decryptBlock)
        {
                        #line 32 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
            global::haxe.io.Bytes vector = iv.sub(0, iv.length);
            int i = 0;
                        #line 34 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
            int len = src.length;
            while ((i < len))
            {
                                #line 37 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                global::haxe.io.Bytes cipherText = src.sub(i, blockSize);
                decryptBlock.__hx_invoke4_o(default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined, default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined);
                                #line 39 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                {
                                        #line 39 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    int _g = 0;
                                        #line 39 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    int _g1 = blockSize;
                                        #line 39 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    while ((_g < _g1))
                    {
                                                #line 39 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                        int j = _g++;
                        src.b[(i + j)] = ((byte)((((int)(((byte)(src.b[(i + j)])))) ^ ((int)(((byte)(vector.b[j])))))));
                    }
                }

                                #line 41 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                vector = src.sub(i, blockSize);
                {
                                        #line 42 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    int _g2 = 0;
                                        #line 42 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    int _g3 = blockSize;
                                        #line 42 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                    while ((_g2 < _g3))
                    {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                        int j1 = _g2++;
                                                #line 44 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                        vector.b[j1] = ((byte)((((int)(((byte)(vector.b[j1])))) ^ ((int)(((byte)(cipherText.b[j1])))))));
                    }
                }

                                #line 46 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\PCBC.hx"
                i += blockSize;
            }
        }
Exemple #5
0
 public static void decrypt(global::haxe.io.Bytes src, global::haxe.io.Bytes iv, int blockSize, global::haxe.lang.Function decryptBlock)
 {
                 #line 27 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
     int vpos = (src.length - blockSize);
     int i    = src.length;
                 #line 29 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
     while ((i > 0))
     {
                         #line 31 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
         i    -= blockSize;
         vpos -= blockSize;
                         #line 34 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
         decryptBlock.__hx_invoke4_o(default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined, default(double), src, ((double)(i)), global::haxe.lang.Runtime.undefined);
                         #line 36 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
         if ((vpos < 0))
         {
                                 #line 37 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             int _g = 0;
                                 #line 37 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             int _g1 = blockSize;
                                 #line 37 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             while ((_g < _g1))
             {
                                         #line 37 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                 int j = _g++;
                 src.b[j] = ((byte)((((int)(((byte)(src.b[j])))) ^ ((int)(((byte)(iv.b[j])))))));
             }
         }
         else
         {
                                 #line 40 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             int _g2 = 0;
                                 #line 40 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             int _g11 = blockSize;
                                 #line 40 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
             while ((_g2 < _g11))
             {
                                         #line 40 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\CBC.hx"
                 int j1 = _g2++;
                 src.b[(i + j1)] = ((byte)((((int)(((byte)(src.b[(i + j1)])))) ^ ((int)(((byte)(src.b[(vpos + j1)])))))));
             }
         }
     }
 }
Exemple #6
0
        public static void encrypt(global::haxe.io.Bytes src, global::haxe.io.Bytes iv, int blockSize, global::haxe.lang.Function encryptBlock)
        {
                        #line 9 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
            global::haxe.io.Bytes vector = iv.sub(0, iv.length);
            int i = 0;
                        #line 11 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
            int len = src.length;
            global::haxe.io.Bytes chiperText = null;
                        #line 13 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
            while ((i < len))
            {
                                #line 15 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                encryptBlock.__hx_invoke4_o(default(double), vector, ((double)(0)), global::haxe.lang.Runtime.undefined, default(double), vector, ((double)(0)), global::haxe.lang.Runtime.undefined);
                chiperText = vector.sub(0, vector.length);
                                #line 17 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                int block = ((((i + blockSize) > len)) ? ((len - i)) : (blockSize));
                {
                                        #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                    int _g = 0;
                                        #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                    int _g1 = block;
                                        #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                    while ((_g < _g1))
                    {
                                                #line 18 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                        int j = _g++;
                                                #line 20 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                        src.b[(i + j)] = ((byte)((((int)(((byte)(src.b[(i + j)])))) ^ ((int)(((byte)(vector.b[j])))))));
                    }
                }

                                #line 22 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                vector = chiperText.sub(0, chiperText.length);
                                #line 24 "C:\\HaxeToolkit\\haxe\\lib\\crypto\\0,3,0\\src\\haxe\\crypto\\mode\\OFB.hx"
                i += blockSize;
            }
        }
        public static void addBytes(global::haxe.io.Bytes bytes, global::server.IHander hander, global::haxe.lang.Function callBack)
        {
            unchecked {
                                #line 360 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                if ((hander != null))
                {
                                        #line 361 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    return;
                }

                                #line 363 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                if ((bytes == null))
                {
                                        #line 364 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    return;
                }

                                #line 367 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                if ((bytes.length > 1000))
                {
                                        #line 368 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    callBack.__hx_invoke4_o(default(double), false, default(double), null, default(double), global::web.proto.Web_Error.ERROR, default(double), hander);
                }

                                #line 371 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                if ((global::web.proto.PacketBuilder.bytesBuff == null))
                {
                                        #line 372 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    global::web.proto.PacketBuilder.bytesBuff = bytes;
                }
                else
                {
                                        #line 374 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    global::haxe.io.BytesBuffer buffer = new global::haxe.io.BytesBuffer();
                    {
                                                #line 375 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        global::haxe.io.Bytes src = global::web.proto.PacketBuilder.bytesBuff;
                                                #line 375 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        (buffer.b as global::System.IO.Stream).Write(((byte[])(src.b)), ((int)(0)), ((int)(src.length)));
                    }

                                        #line 376 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    (buffer.b as global::System.IO.Stream).Write(((byte[])(bytes.b)), ((int)(0)), ((int)(bytes.length)));
                    global::web.proto.PacketBuilder.bytesBuff = buffer.getBytes();
                }

                                #line 379 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                if (((global::web.proto.PacketBuilder.bytesBuff == null) || (global::web.proto.PacketBuilder.bytesBuff.length < 10)))
                {
                                        #line 380 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    return;
                }

                                #line 382 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                int available = global::web.proto.PacketBuilder.bytesBuff.length;
                global::haxe.io.BytesInput bi = new global::haxe.io.BytesInput(global::web.proto.PacketBuilder.bytesBuff, null, null);
                                #line 384 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                bi.set_bigEndian(false);
                while ((available >= 10))
                {
                                        #line 387 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    int z = bi.readByte();
                    int h = bi.readByte();
                                        #line 389 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    int y  = bi.readByte();
                    int v1 = bi.readByte();
                                        #line 391 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    int v2 = bi.readByte();
                    int v3 = bi.readByte();
                                        #line 393 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    int packetSize = bi.readInt32();
                    available -= 10;
                                        #line 396 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    if (!(global::web.proto.PacketBuilder.checkKey(z, h, y, v1, v2, v3)))
                    {
                                                #line 397 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        global::web.proto.PacketBuilder.bytesBuff = null;
                        global::haxe.Log.trace.__hx_invoke2_o(default(double), "f**k you !!! error message", default(double), new global::haxe.lang.DynamicObject(new int[] { 302979532, 1547539107, 1648581351 }, new object[] { "addBytes", "web.proto.PacketBuilder", "src/web/proto/PacketBuilder.hx" }, new int[] { 1981972957 }, new double[] { ((double)(398)) }));
                                                #line 399 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        available = 0;
                        callBack.__hx_invoke4_o(default(double), false, default(double), null, default(double), global::web.proto.Web_Error.ERROR, default(double), hander);
                                                #line 402 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        break;
                    }

                                        #line 405 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                    bool error = false;
                    if ((packetSize <= available))
                    {
                                                #line 407 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        available -= packetSize;
                        global::haxe.io.Bytes msgBytes = bi.read(packetSize);
                                                #line 410 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        try {
                                                        #line 411 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                            object p = global::org.msgpack.MsgPack.decode(msgBytes, null);
                                                        #line 413 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                            callBack.__hx_invoke4_o(default(double), true, default(double), p, default(double), global::web.proto.Web_Error.OK, default(double), hander);
                        }
                        catch (global::System.Exception catchallException) {
                                                        #line 410 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                            global::haxe.lang.Exceptions.exception = catchallException;
                                                        #line 415 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                            {
                                                                #line 415 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                                object e = (((catchallException is global::haxe.lang.HaxeException)) ? (((global::haxe.lang.HaxeException)(catchallException)).obj) : ((object)(catchallException)));
                                                                #line 415 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                                callBack.__hx_invoke4_o(default(double), false, default(double), null, default(double), global::web.proto.Web_Error.ERROR, default(double), hander);
                            }
                        }


                                                #line 417 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        break;
                    }
                    else
                    {
                                                #line 420 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        available += 10;
                                                #line 422 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                        break;
                    }
                }

                                #line 425 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                global::web.proto.PacketBuilder.bytesBuff = null;
                available = 0;
                                #line 428 "D:\\project\\sangong\\sangong\\src\\web\\proto\\PacketBuilder.hx"
                return;
            }
                        #line default
        }