*/

#ifndef C_once_88F44E4C_C507_47B8_A162_CBEC13D572DA
#define C_once_88F44E4C_C507_47B8_A162_CBEC13D572DA

#ifdef _LIBYOYO
#define _YO_AES_BUILTIN
#endif

#include "yoyo.hc"
#include "cipher.hc"
#include "md5.hc"
#include "sha2.hc"

typedef struct _YO_AES
  {
    int nr;
    uint_t *rk;
    uint_t rawk[68];
  } YO_AES;

void Aes_Destruct(YO_AES *ctx)
#ifdef _YO_AES_BUILTIN
  {
    __Destruct(ctx);
  }
#endif
  ;

#ifdef _YO_AES_BUILTIN

  static byte_t YO_AES_FSb[256] =
    {
      0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
      0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
      0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
      0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
      0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
      0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,

      0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
      0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
      0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
      0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
      0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
    };

  static uint_t YO_AES_FT0[256] =
    {
      0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6,
      0x0df2f2ff, 0xbd6b6bd6, 0xb16f6fde, 0x54c5c591,
      0x50303060, 0x03010102, 0xa96767ce, 0x7d2b2b56,
      0x19fefee7, 0x62d7d7b5, 0xe6abab4d, 0x9a7676ec,
      0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa,
      0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb,

      0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5,
      0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a,
      0xdabfbf65, 0x31e6e6d7, 0xc6424284, 0xb86868d0,
      0xc3414182, 0xb0999929, 0x772d2d5a, 0x110f0f1e,
      0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d, 0x3a16162c
    };

  static uint_t YO_AES_FT1[256] =
    {
      0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d,
      0xf2f2ff0d, 0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154,
      0x30306050, 0x01010203, 0x6767cea9, 0x2b2b567d,
      0xfefee719, 0xd7d7b562, 0xabab4de6, 0x7676ec9a,
      0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87,
      0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b,

      0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a,
      0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17,
      0xbfbf65da, 0xe6e6d731, 0x424284c6, 0x6868d0b8,
      0x414182c3, 0x999929b0, 0x2d2d5a77, 0x0f0f1e11,
      0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6, 0x16162c3a
    };

  static uint_t YO_AES_FT2[256] =
    {
      0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b,
      0xf2ff0df2, 0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5,
      0x30605030, 0x01020301, 0x67cea967, 0x2b567d2b,
      0xfee719fe, 0xd7b562d7, 0xab4de6ab, 0x76ec9a76,
      0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d,
      0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0,

      0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf,
      0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d,
      0xbf65dabf, 0xe6d731e6, 0x4284c642, 0x68d0b868,
      0x4182c341, 0x9929b099, 0x2d5a772d, 0x0f1e110f,
      0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb, 0x162c3a16
    };

  static uint_t YO_AES_FT3[256] =
    {
      0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b,
      0xff0df2f2, 0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5,
      0x60503030, 0x02030101, 0xcea96767, 0x567d2b2b,
      0xe719fefe, 0xb562d7d7, 0x4de6abab, 0xec9a7676,
      0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d,
      0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0,

      0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf,
      0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d,
      0x65dabfbf, 0xd731e6e6, 0x84c64242, 0xd0b86868,
      0x82c34141, 0x29b09999, 0x5a772d2d, 0x1e110f0f,
      0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb, 0x2c3a1616
    };

  static byte_t YO_AES_RSb[256] =
    {
      0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
      0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
      0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
      0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
      0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
      0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,

      0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
      0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
      0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
      0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
      0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
    };

  static uint_t YO_AES_RT0[256] =
    {
      0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a,
      0xcb6bab3b, 0xf1459d1f, 0xab58faac, 0x9303e34b,
      0x55fa3020, 0xf66d76ad, 0x9176cc88, 0x254c02f5,
      0xfcd7e54f, 0xd7cb2ac5, 0x80443526, 0x8fa362b5,
      0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d,
      0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b,

      0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478,
      0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2,
      0x72c31d16, 0x0c25e2bc, 0x8b493c28, 0x41950dff,
      0x7101a839, 0xdeb30c08, 0x9ce4b4d8, 0x90c15664,
      0x6184cb7b, 0x70b632d5, 0x745c6c48, 0x4257b8d0
    };

  static uint_t YO_AES_RT1[256] =
    {
      0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96,
      0x6bab3bcb, 0x459d1ff1, 0x58faacab, 0x03e34b93,
      0xfa302055, 0x6d76adf6, 0x76cc8891, 0x4c02f525,
      0xd7e54ffc, 0xcb2ac5d7, 0x44352680, 0xa362b58f,
      0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1,
      0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6,

      0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886,
      0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f,
      0xc31d1672, 0x25e2bc0c, 0x493c288b, 0x950dff41,
      0x01a83971, 0xb30c08de, 0xe4b4d89c, 0xc1566490,
      0x84cb7b61, 0xb632d570, 0x5c6c4874, 0x57b8d042
    };

  static uint_t YO_AES_RT2[256] =
    {
      0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e,
      0xab3bcb6b, 0x9d1ff145, 0xfaacab58, 0xe34b9303,
      0x302055fa, 0x76adf66d, 0xcc889176, 0x02f5254c,
      0xe54ffcd7, 0x2ac5d7cb, 0x35268044, 0x62b58fa3,
      0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0,
      0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9,

      0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db,
      0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40,
      0x1d1672c3, 0xe2bc0c25, 0x3c288b49, 0x0dff4195,
      0xa8397101, 0x0c08deb3, 0xb4d89ce4, 0x566490c1,
      0xcb7b6184, 0x32d570b6, 0x6c48745c, 0xb8d04257
    };

  static uint_t YO_AES_RT3[256] =
    {
      0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27,
      0x3bcb6bab, 0x1ff1459d, 0xacab58fa, 0x4b9303e3,
      0x2055fa30, 0xadf66d76, 0x889176cc, 0xf5254c02,
      0x4ffcd7e5, 0xc5d7cb2a, 0x26804435, 0xb58fa362,
      0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe,
      0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3,

      0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,
      0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3,
      0x1672c31d, 0xbc0c25e2, 0x288b493c, 0xff41950d,
      0x397101a8, 0x08deb30c, 0xd89ce4b4, 0x6490c156,
      0x7b6184cb, 0xd570b632, 0x48745c6c, 0xd04257b8
    };

  static uint_t YO_AES_RCON[10] =
    {
      0x00000001, 0x00000002, 0x00000004, 0x00000008,
      0x00000010, 0x00000020, 0x00000040, 0x00000080,
      0x0000001b, 0x00000036
    };

#endif


#if defined _X86 || defined __i386 || defined __x86_64
  #define Aes_Internal_Encode memcpy
  #define Aes_Internal_Decode memcpy
#else
  void Aes_Internal_Encode(byte_t *output, uint_t *input, uint_t len)
  #ifdef _YO_AES_BUILTIN
    {
      uint_t i, j;

      for (i = 0, j = 0; j < len; i++, j += 4)
        {
          output[j]   = (byte_t)(input[i] & 0xff);
          output[j+1] = (byte_t)((input[i] >> 8) & 0xff);
          output[j+2] = (byte_t)((input[i] >> 16) & 0xff);
          output[j+3] = (byte_t)((input[i] >> 24) & 0xff);
        }
    }
  #endif
    ;

  void Aes_Internal_Decode(uint_t *output, byte_t *input, uint_t len)
  #ifdef _YO_AES_BUILTIN
    {
      uint_t i, j;

      for (i = 0, j = 0; j < len; i++, j += 4)
        output[i] = ((uint_t)input[j]) | (((uint_t)input[j+1]) << 8) |
          (((uint_t)input[j+2]) << 16) | (((uint_t)input[j+3]) << 24);
    }
  #endif
    ;

#endif

void *Aes_Init_Encipher_Static(YO_AES *ctx, void *key, int key_len_bits)
#ifdef _YO_AES_BUILTIN
  {
    int i;
    uint_t *RK;

    switch(key_len_bits)
      {
        case 128: ctx->nr = 10; break;
        case 192: ctx->nr = 12; break;
        case 256: ctx->nr = 14; break;
        default:
        __Raise_Format(YO_ERROR_UNSUPPORTED,("unsupported key length %d bit",key_len_bits));
      }

    RK = ctx->rk = ctx->rawk;
    Aes_Internal_Decode(RK,key,key_len_bits/8);

    switch( ctx->nr )
      {
        case 10:
          for( i = 0; i < 10; i++, RK += 4 )
            {
              RK[4]  = RK[0] ^ YO_AES_RCON[i] ^
              ( (uint_t) YO_AES_FSb[ ( RK[3] >>  8 ) & 0x0ff ]       ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[3] >> 16 ) & 0x0ff ] <<  8 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[3] >> 24 ) & 0x0ff ] << 16 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[3]       ) & 0x0ff ] << 24 );

              RK[5]  = RK[1] ^ RK[4];
              RK[6]  = RK[2] ^ RK[5];
              RK[7]  = RK[3] ^ RK[6];
            }
          break;

        case 12:
          for( i = 0; i < 8; i++, RK += 6 )
            {
              RK[6]  = RK[0] ^ YO_AES_RCON[i] ^
              ( (uint_t) YO_AES_FSb[ ( RK[5] >>  8 ) & 0x0ff ]       ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[5] >> 16 ) & 0x0ff ] <<  8 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[5] >> 24 ) & 0x0ff ] << 16 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[5]       ) & 0x0ff ] << 24 );

              RK[7]  = RK[1] ^ RK[6];
              RK[8]  = RK[2] ^ RK[7];
              RK[9]  = RK[3] ^ RK[8];
              RK[10] = RK[4] ^ RK[9];
              RK[11] = RK[5] ^ RK[10];
            }
          break;

        case 14:
          for( i = 0; i < 7; i++, RK += 8 )
            {
              RK[8]  = RK[0] ^ YO_AES_RCON[i] ^
              ( (uint_t) YO_AES_FSb[ ( RK[7] >>  8 ) & 0x0ff ]       ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[7] >> 16 ) & 0x0ff ] <<  8 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[7] >> 24 ) & 0x0ff ] << 16 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[7]       ) & 0x0ff ] << 24 );

              RK[9]  = RK[1] ^ RK[8];
              RK[10] = RK[2] ^ RK[9];
              RK[11] = RK[3] ^ RK[10];

              RK[12] = RK[4] ^
              ( (uint_t) YO_AES_FSb[ ( RK[11]       ) & 0x0ff ]       ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[11] >>  8 ) & 0x0ff ] <<  8 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[11] >> 16 ) & 0x0ff ] << 16 ) ^
              ( (uint_t) YO_AES_FSb[ ( RK[11] >> 24 ) & 0x0ff ] << 24 );

              RK[13] = RK[5] ^ RK[12];
              RK[14] = RK[6] ^ RK[13];
              RK[15] = RK[7] ^ RK[14];
            }
          break;

        default:
          break;
      }

    return ctx;
  }
#endif
  ;

void *Aes_Init_Decipher_Static(YO_AES *ctx, void *key, int key_len_bits)
#ifdef _YO_AES_BUILTIN
  {
    int i,j;
    uint_t *RK, *SK;
    YO_AES cty = { 0, 0, {0} };
    Aes_Init_Encipher_Static(&cty,key,key_len_bits);
    RK = ctx->rk = ctx->rawk;
    ctx->nr = cty.nr;
    SK = cty.rk + cty.nr * 4;

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
    {
        for( j = 0; j < 4; j++, SK++ )
        {
            *RK++ = YO_AES_RT0[ YO_AES_FSb[ ( *SK       ) & 0x0ff ] ] ^
                    YO_AES_RT1[ YO_AES_FSb[ ( *SK >>  8 ) & 0x0ff ] ] ^
                    YO_AES_RT2[ YO_AES_FSb[ ( *SK >> 16 ) & 0x0ff ] ] ^
                    YO_AES_RT3[ YO_AES_FSb[ ( *SK >> 24 ) & 0x0ff ] ];
        }
    }

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    memset( &cty, 0, sizeof(cty) );
    return ctx;
  }
#endif
  ;

#define FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
  { \
    X0 = *RK++ ^ YO_AES_FT0[ ( Y0       ) & 0x0ff ] ^\
                 YO_AES_FT1[ ( Y1 >>  8 ) & 0x0ff ] ^\
                 YO_AES_FT2[ ( Y2 >> 16 ) & 0x0ff ] ^\
                 YO_AES_FT3[ ( Y3 >> 24 ) & 0x0ff ]; \
\
    X1 = *RK++ ^ YO_AES_FT0[ ( Y1       ) & 0x0ff ] ^\
                 YO_AES_FT1[ ( Y2 >>  8 ) & 0x0ff ] ^\
                 YO_AES_FT2[ ( Y3 >> 16 ) & 0x0ff ] ^\
                 YO_AES_FT3[ ( Y0 >> 24 ) & 0x0ff ]; \
\
    X2 = *RK++ ^ YO_AES_FT0[ ( Y2       ) & 0x0ff ] ^\
                 YO_AES_FT1[ ( Y3 >>  8 ) & 0x0ff ] ^\
                 YO_AES_FT2[ ( Y0 >> 16 ) & 0x0ff ] ^\
                 YO_AES_FT3[ ( Y1 >> 24 ) & 0x0ff ]; \
\
    X3 = *RK++ ^ YO_AES_FT0[ ( Y3       ) & 0x0ff ] ^\
                 YO_AES_FT1[ ( Y0 >>  8 ) & 0x0ff ] ^\
                 YO_AES_FT2[ ( Y1 >> 16 ) & 0x0ff ] ^\
                 YO_AES_FT3[ ( Y2 >> 24 ) & 0x0ff ]; \
  }

void Aes_Encrypt16( YO_AES *ctx, void *block16 )
#ifdef _YO_AES_BUILTIN
  {
    int i;
    uint_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
    RK = ctx->rk;

    X0 = Four_To_Unsigned((byte_t*)block16+0)  ^ *RK++;
    X1 = Four_To_Unsigned((byte_t*)block16+4)  ^ *RK++;
    X2 = Four_To_Unsigned((byte_t*)block16+8)  ^ *RK++;
    X3 = Four_To_Unsigned((byte_t*)block16+12) ^ *RK++;

    /* AES_ENCRYPT */
    for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
      {
        FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
        FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
      }

    FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );

    X0 = *RK++ ^ \
            ( (uint_t) YO_AES_FSb[ ( Y0       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_FSb[ ( Y1 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y2 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y3 >> 24 ) & 0x0ff ] << 24 );

    X1 = *RK++ ^ \
            ( (uint_t) YO_AES_FSb[ ( Y1       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_FSb[ ( Y2 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y3 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y0 >> 24 ) & 0x0ff ] << 24 );

    X2 = *RK++ ^ \
            ( (uint_t) YO_AES_FSb[ ( Y2       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_FSb[ ( Y3 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y0 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y1 >> 24 ) & 0x0ff ] << 24 );

    X3 = *RK++ ^ \
            ( (uint_t) YO_AES_FSb[ ( Y3       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_FSb[ ( Y0 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y1 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_FSb[ ( Y2 >> 24 ) & 0x0ff ] << 24 );

    Unsigned_To_Four( X0, (byte_t*)block16+0 );
    Unsigned_To_Four( X1, (byte_t*)block16+4 );
    Unsigned_To_Four( X2, (byte_t*)block16+8 );
    Unsigned_To_Four( X3, (byte_t*)block16+12 );
  }
#endif
  ;

#undef FROUND

#define RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
  { \
    X0 = *RK++ ^ YO_AES_RT0[ ( Y0       ) & 0x0ff ] ^\
                 YO_AES_RT1[ ( Y3 >>  8 ) & 0x0ff ] ^\
                 YO_AES_RT2[ ( Y2 >> 16 ) & 0x0ff ] ^\
                 YO_AES_RT3[ ( Y1 >> 24 ) & 0x0ff ]; \
\
    X1 = *RK++ ^ YO_AES_RT0[ ( Y1       ) & 0x0ff ] ^\
                 YO_AES_RT1[ ( Y0 >>  8 ) & 0x0ff ] ^\
                 YO_AES_RT2[ ( Y3 >> 16 ) & 0x0ff ] ^\
                 YO_AES_RT3[ ( Y2 >> 24 ) & 0x0ff ]; \
\
    X2 = *RK++ ^ YO_AES_RT0[ ( Y2       ) & 0x0ff ] ^\
                 YO_AES_RT1[ ( Y1 >>  8 ) & 0x0ff ] ^\
                 YO_AES_RT2[ ( Y0 >> 16 ) & 0x0ff ] ^\
                 YO_AES_RT3[ ( Y3 >> 24 ) & 0x0ff ]; \
\
    X3 = *RK++ ^ YO_AES_RT0[ ( Y3       ) & 0x0ff ] ^\
                 YO_AES_RT1[ ( Y2 >>  8 ) & 0x0ff ] ^\
                 YO_AES_RT2[ ( Y1 >> 16 ) & 0x0ff ] ^\
                 YO_AES_RT3[ ( Y0 >> 24 ) & 0x0ff ]; \
  }

void Aes_Decrypt16( YO_AES *ctx, void *block16 )
#ifdef _YO_AES_BUILTIN
  {
    int i;
    uint_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
    RK = ctx->rk;

    X0 = Four_To_Unsigned((byte_t*)block16+0)  ^ *RK++;
    X1 = Four_To_Unsigned((byte_t*)block16+4)  ^ *RK++;
    X2 = Four_To_Unsigned((byte_t*)block16+8)  ^ *RK++;
    X3 = Four_To_Unsigned((byte_t*)block16+12) ^ *RK++;

    for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
      {
        RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
        RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
      }

    RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );

    X0 = *RK++ ^ \
            ( (uint_t) YO_AES_RSb[ ( Y0       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_RSb[ ( Y3 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y2 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y1 >> 24 ) & 0x0ff ] << 24 );

    X1 = *RK++ ^ \
            ( (uint_t) YO_AES_RSb[ ( Y1       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_RSb[ ( Y0 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y3 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y2 >> 24 ) & 0x0ff ] << 24 );

    X2 = *RK++ ^ \
            ( (uint_t) YO_AES_RSb[ ( Y2       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_RSb[ ( Y1 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y0 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y3 >> 24 ) & 0x0ff ] << 24 );

    X3 = *RK++ ^ \
            ( (uint_t) YO_AES_RSb[ ( Y3       ) & 0x0ff ]       ) ^
            ( (uint_t) YO_AES_RSb[ ( Y2 >>  8 ) & 0x0ff ] <<  8 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y1 >> 16 ) & 0x0ff ] << 16 ) ^
            ( (uint_t) YO_AES_RSb[ ( Y0 >> 24 ) & 0x0ff ] << 24 );

    Unsigned_To_Four( X0, (byte_t*)block16+0 );
    Unsigned_To_Four( X1, (byte_t*)block16+4 );
    Unsigned_To_Four( X2, (byte_t*)block16+8 );
    Unsigned_To_Four( X3, (byte_t*)block16+12 );
  }
#endif
  ;

#undef RROUND

void *Aes_Init_Encipher(void *key,int key_len)
#ifdef _YO_AES_BUILTIN
  {
    static YO_FUNCTABLE funcs[] =
      { {0},
        {Oj_Destruct_OjMID,  Aes_Destruct},
        {Oj_Encrypt16_OjMID, Aes_Encrypt16},
        {0}};

    YO_AES *ctx = __Object(sizeof(YO_AES),funcs);
    return Aes_Init_Encipher_Static(ctx,key,key_len);
  }
#endif
  ;

void *Aes_Encipher(char *S)
#ifdef _YO_AES_BUILTIN
  {
    byte_t key[32];
    Sha2_Digest_Digest(S,strlen(S),key);
    return Aes_Init_Encipher(key,256);
  }
#endif
  ;


void *Aes_Init_Decipher(void *key,int key_len)
#ifdef _YO_AES_BUILTIN
  {
    static YO_FUNCTABLE funcs[] =
      { {0},
        {Oj_Destruct_OjMID,  Aes_Destruct},
        {Oj_Decrypt16_OjMID, Aes_Decrypt16},
        {0}};

    YO_AES *ctx = __Object(sizeof(YO_AES),funcs);
    return Aes_Init_Decipher_Static(ctx,key,key_len);
  }
#endif
  ;

void *Aes_Decipher(char *S)
#ifdef _YO_AES_BUILTIN
  {
    byte_t key[32];
    Sha2_Digest_Digest(S,strlen(S),key);
    return Aes_Init_Decipher(key,256);
  }
#endif
  ;

void Aes_Encrypt(char *data, int len, char *S)
#ifdef _YO_AES_BUILTIN
  {
    int i;
    YO_AES actx = {0,0,{0}};
    byte_t key[32];
    Sha2_Digest_Digest(S,strlen(S),key);
    Aes_Init_Encipher_Static(&actx,key,256);

    for ( i = 0; i < len && len-i >= 16 ; i += 16 )
      {
        Aes_Encrypt16(&actx,data+i);
      }
  }
#endif
  ;

void Aes_Decrypt(char *data, int len, char *S)
#ifdef _YO_AES_BUILTIN
  {
    int i;
    YO_AES actx = {0,0,{0}};
    byte_t key[32];
    Sha2_Digest_Digest(S,strlen(S),key);
    Aes_Init_Decipher_Static(&actx,key,256);

    for ( i = 0; i < len && len-i >= 16 ; i += 16 )
      {
        Aes_Decrypt16(&actx,data+i);

*/

#ifndef C_once_44A7F9A5_269A_48D5_AABB_F08291F9087B
#define C_once_44A7F9A5_269A_48D5_AABB_F08291F9087B

#ifdef _LIBYOYO
#define _YO_ARRAY_BUILTIN
#endif

#include "yoyo.hc"

#ifdef _YO_ARRAY_BUILTIN
# define _YO_ARRAY_BUILTIN_CODE(Code) Code
# define _YO_ARRAY_EXTERN 
#else
# define _YO_ARRAY_BUILTIN_CODE(Code)
# define _YO_ARRAY_EXTERN extern 
#endif

_YO_ARRAY_EXTERN char Oj_Sort_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = ">>>/@" );
_YO_ARRAY_EXTERN char Oj_Push_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "$+/@*" );
_YO_ARRAY_EXTERN char Oj_Pop_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "$-/@" );
_YO_ARRAY_EXTERN char Oj_Pop_Npl_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "`$-/@" );
_YO_ARRAY_EXTERN char Oj_Sorted_Insert_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = ">1>/@*" );
_YO_ARRAY_EXTERN char Oj_Sorted_Find_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = ">?>/@*" );
_YO_ARRAY_EXTERN char Oj_Push_Front_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "+$/@*" );
_YO_ARRAY_EXTERN char Oj_Pop_Front_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "-$/@" );
_YO_ARRAY_EXTERN char Oj_Pop_Front_Npl_OjMID[] _YO_ARRAY_BUILTIN_CODE ( = "`-$/@" );

void Oj_Sort(void *self)
#ifdef _YO_ARRAY_BUILTIN
  {
    void (*sort)(void *) = Yo_Find_Method_Of(&self,Oj_Sort_OjMID,YO_RAISE_ERROR);
    sort(self);
  }
#endif
  ;

void Oj_Sorted_Insert(void *self, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    void (*insert)(void *, void *) = Yo_Find_Method_Of(&self,Oj_Sorted_Insert_OjMID,YO_RAISE_ERROR);
    insert(self,val);
  }
#endif
  ;

void *Oj_Sorted_Find(void *self, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *(*find)(void *, void *) = Yo_Find_Method_Of(&self,Oj_Sorted_Find_OjMID,YO_RAISE_ERROR);
    return find(self,val);
  }
#endif
  ;

void Oj_Push(void *self, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    void (*push)(void *, void *) = Yo_Find_Method_Of(&self,Oj_Push_OjMID,YO_RAISE_ERROR);
    push(self,val);
  }
#endif
  ;

void *Oj_Pop(void *self)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *(*pop)(void *) = Yo_Find_Method_Of(&self,Oj_Pop_OjMID,YO_RAISE_ERROR);
    return pop(self);
  }
#endif
  ;

void *Oj_Pop_Npl(void *self)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *(*pop)(void *) = Yo_Find_Method_Of(&self,Oj_Pop_Npl_OjMID,YO_RAISE_ERROR);
    return pop(self);
  }
#endif
  ;

void Oj_Push_Front(void *self, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    void (*push)(void *, void *) = Yo_Find_Method_Of(&self,Oj_Push_Front_OjMID,YO_RAISE_ERROR);
    push(self,val);
  }
#endif
  ;

void *Oj_Pop_Front_Npl(void *self)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *(*pop)(void *) = Yo_Find_Method_Of(&self,Oj_Pop_Front_Npl_OjMID,YO_RAISE_ERROR);
    return pop(self);
  }
#endif
  ;

void *Oj_Pop_Front(void *self)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *(*pop)(void *) = Yo_Find_Method_Of(&self,Oj_Pop_Front_OjMID,YO_RAISE_ERROR);
    return pop(self);
  }
#endif
  ;

void *Lower_Boundary(void **S, int S_len, void *compare, void *val, int *found)
#ifdef _YO_ARRAY_BUILTIN
  {
    typedef int (*Tcmp)(void *,void*);
    int cmp_r = 0;
    void **iS = S;
    void **middle = iS;
    int half;
    int len = S_len;

      
    *found = !cmp_r;
    return iS;
  }
#endif
  ;

typedef struct _YO_ARRAY
  {
    void **at;
    int count;
    int capacity;
  } YO_ARRAY;

void Array_Del(YO_ARRAY *a,int pos,int n)
#ifdef _YO_ARRAY_BUILTIN
  {
    int i;
    void *self = a;
    void (*destruct)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);

    if ( pos < 0 ) pos = a->count + pos;
    if ( n < 0 || pos + n > a->count ) n = a->count-pos;
    if ( pos < 0 || pos+n > a->count ) 
      Yo_Raise(YO_ERROR_OUT_OF_RANGE,0,__Yo_FILE__,__LINE__);

    if ( destruct )
      for ( i = 0; i < n; ++i )
        destruct((a->at)[i+pos]);
    
    if ( pos != a->count-n )
      memmove(a->at+pos,a->at+(pos+n),(a->count-(pos+n))*sizeof(void*));
    a->count -= n;
  }
#endif
  ;

void *Array_Take_Npl(YO_ARRAY *a,int pos)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *Q = 0;
    
    if ( pos < 0 ) pos = a->count + pos;
    if ( pos < 0 || pos >= a->count ) 
      Yo_Raise(YO_ERROR_OUT_OF_RANGE,0,__Yo_FILE__,__LINE__);

    Q = (a->at)[pos];
    
    if ( pos != a->count-1 )
      memmove(a->at+pos,a->at+(pos+1),(a->count-(pos+1))*sizeof(void*));
    a->count -= 1;
    
    return Q;
  }
#endif
  ;

void *Array_Take(YO_ARRAY *a,int pos)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *self = a;
    void (*destruct)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,YO_RAISE_ERROR);
    void *Q = Array_Take_Npl(a,pos);
    
    if ( Q )
      Yo_Pool_Ptr(Q,destruct);
    
    return Q;
  }
#endif
  ;

void Array_Grow(YO_ARRAY *a,int require)
#ifdef _YO_ARRAY_BUILTIN
  {
    int capacity = Min_Pow2(require*sizeof(void*));
    if ( !a->at || a->capacity < capacity )
      {
        a->at = Yo_Realloc_Npl(a->at,capacity);
        a->capacity = capacity;
      }
  }
#endif
  ;
  
void Array_Insert(YO_ARRAY *a,int pos,void *p)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( pos < 0 ) pos = a->count + pos + 1;
    if ( pos < 0 || pos > a->count ) 
      {
        void *self = a;
        void (*destruct)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
        if ( destruct ) destruct(p);
        Yo_Raise(YO_ERROR_OUT_OF_RANGE,0,__Yo_FILE__,__LINE__);
      }
    
    Array_Grow(a,a->count+1);
    if ( pos < a->count )
      memmove(a->at+pos+1,a->at+pos,(a->count-pos)*sizeof(void*));
    a->at[pos] = p;
    ++a->count;
  }
#endif
  ;

void Array_Fill(YO_ARRAY *a,int pos,void *p, int count)
#ifdef _YO_ARRAY_BUILTIN
  {
    int i;
    
    if ( !count ) return;
    else if ( count < 0 || pos < 0 ) 
      Yo_Raise(YO_ERROR_INVALID_PARAM,0,__Yo_FILE__,__LINE__);
    
    if ( !a->at || a->count-pos < count )
      {
        Array_Grow(a,a->count-pos+count);
        memset(a->at+pos,0,sizeof(void*)*count);
        a->count = a->count-pos+count;
      }

          }
        a->at[pos+i] = p;
      }
  }
#endif
  ;

void Array_Set(YO_ARRAY *a,int pos,void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *self = a;
    void (*destruct)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);

    if ( pos < 0 ) pos = a->count + pos;
    if ( pos < 0 || pos >= a->count ) 
      {
        if ( destruct ) destruct(val);
        __Raise(YO_ERROR_OUT_OF_RANGE,0);
      }
      
    if ( destruct )
      destruct((a->at)[pos]);

    a->at[pos] = val;
  }
#endif
  ;

int Array_Sorted_Lower_Boundary(YO_ARRAY *a,void *val,int *found,int except)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *self = a;
    int (*compare)(void *, void *);
    
    if ( !a->count ) 
      {
        *found = 0;
        return 0;
      }
    
    if ( 0 != (compare = Yo_Find_Method_Of(&self,Oj_Compare_Elements_OjMID,0)) )
      {
        void **p = Lower_Boundary(a->at,a->count,compare,val,found);
        return p - a->at;
      }
    else if (except)
      __Raise(YO_ERROR_UNSORTABLE,__yoTa("array is unsortable",0));
    else
      return -1;
      
    return 0;
  }
#endif
  ;

void Array_Sorted_Insert(YO_ARRAY *a,void *p)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( !a->count )
      Array_Insert(a,-1,p);
    else
      {
        int found = 0;
        int pos ;
        
        pos = Array_Sorted_Lower_Boundary(a,p,&found,0);
        
        if ( pos < 0 )
          {
            void *self = a;
            void (*destructor)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
            if ( destructor )
              destructor(p);
            __Raise(YO_ERROR_UNSORTABLE,__yoTa("array is unsortable",0));
          }
          
        if ( !found )
          Array_Insert(a,pos,p);
        else
          Array_Set(a,pos,p);
      }
  }
#endif
  ;

void *Array_Binary_Find(YO_ARRAY *a, void *p)
#ifdef _YO_ARRAY_BUILTIN
  {
    int found = 0;
    int pos = Array_Sorted_Lower_Boundary(a,p,&found,1);
    return found ? a->at[pos] : 0;
  }
#endif
  ;

#ifdef _YO_ARRAY_BUILTIN
int Array_Sort_Qsort_Compare(int (*compare)(void *a,void *b), void **a, void **b)
  {
    return compare(*a,*b);
  }
int (*Array_Sort_Qsort_Compare_Static_Compare)(void *a,void *b) = 0;
int Array_Sort_Qsort_Compare_Static(void **a, void **b)
  {
    return Array_Sort_Qsort_Compare_Static_Compare(*a,*b);
  }
#endif

void Array_Sort(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *self = a;
    void *compare;
    if ( a->at && a->count )
      {
        if ( 0 != (compare = Yo_Find_Method_Of(&self,Oj_Compare_Elements_OjMID,0)) )
          {
          #if !defined __windoze && !defined __NetBSD__ && !defined __linux__
            qsort_r(a->at,a->count,sizeof(void*),compare,(void*)Array_Sort_Qsort_Compare);
          #elif defined __windoze && _MSC_VER > 1400 
            qsort_s(a->at,a->count,sizeof(void*),compare,(void*)Array_Sort_Qsort_Compare);
          #else /* use global variable */
            __Xchg_Interlock
              {
                Array_Sort_Qsort_Compare_Static_Compare = compare;
                qsort(a->at,a->count,sizeof(void*),(void*)Array_Sort_Qsort_Compare_Static);
              }
          #endif
          }
        else
          __Raise(YO_ERROR_UNSORTABLE,__yoTa("array is unsortable",0));
      }
  }
#endif
  ;

#define Array_COUNT(Arr)          ((int)((YO_ARRAY *)(Arr))->count+0)
#define Array_BEGIN(Arr)          (((YO_ARRAY *)(Arr))->at)
#define Array_END(Arr)            (Array_BEGIN(Arr)+Array_COUNT(Arr))
#define Array_AT(Arr,Idx)         ((((YO_ARRAY *)(Arr))->at)[Idx])
#define Array_Push(Arr,Val)       Array_Insert(Arr,-1,Val)
#define Array_Pop(Arr)            Array_Take(Arr,-1)
#define Array_Pop_Npl(Arr)        Array_Take_Npl(Arr,-1)
#define Array_Push_Front(Arr,Val) Array_Insert(Arr,0,Val)
#define Array_Pop_Front(Arr)      Array_Take(Arr,0)
#define Array_Pop_Front_Npl(Arr)  Array_Take_Npl(Arr,0)

void Array_Push_Oj(YO_ARRAY *a, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    Array_Push(a,val);
  }
#endif
  ;

void *Array_Pop_Oj(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    return Array_Pop(a);
  }
#endif
  ;

void *Array_Pop_Npl_Oj(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    return Array_Pop_Npl(a);
  }
#endif
  ;

void Array_Push_Front_Oj(YO_ARRAY *a, void *val)
#ifdef _YO_ARRAY_BUILTIN
  {
    Array_Push_Front(a,val);
  }
#endif
  ;

void *Array_Pop_Front_Oj(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    return Array_Pop_Front(a);
  }
#endif
  ;

void *Array_Pop_Front_Npl_Oj(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    return Array_Pop_Front_Npl(a);
  }
#endif
  ;

int Array_Count(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( a )
      return Array_COUNT(a);
    return 0;
  }
#endif
  ;
  
void *Array_Begin(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( a )
      return Array_BEGIN(a);
    return 0;
  }
#endif
  ;

void *Array_End(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( a )
      return Array_END(a);
    return 0;
  }
#endif
  ;

void *Array_At(YO_ARRAY *a,int pos)
#ifdef _YO_ARRAY_BUILTIN
  {
    if ( a )
      {
        if ( pos < 0 ) pos = a->count + pos;
        if ( pos < 0 || pos >= a->count ) 
          Yo_Raise(YO_ERROR_OUT_OF_RANGE,0,__Yo_FILE__,__LINE__);
        return Array_AT(a,pos);
      }
    return 0;
  }
#endif
  ;

void Array_Destruct(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    int i = 0;
    void *self = a;
    void (*destructor)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
    if ( destructor )
      for ( i = 0; i < a->count; ++i )
        if ( a->at[i] ) 
          destructor(a->at[i]);
    if ( a->at )
      free(a->at);
    Yo_Object_Destruct(a);
  }
#endif
  ;

void Array_Clear(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    int i = 0;
    void *self = a;
    void (*destructor)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
    if ( destructor )
      for ( i = 0; i < a->count; ++i )
        destructor(a->at[i]);
    if ( a->at )
      memset(a->at,0,a->count*sizeof(a->at[0]));
    a->count = 0;
  }
#endif
  ;

#define Array_Init() Array_Void()
void *Array_Void(void)
#ifdef _YO_ARRAY_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,         Array_Destruct},
        {Oj_Sort_OjMID,             Array_Sort},
        {Oj_Sorted_Insert_OjMID,    Array_Sorted_Insert},
        {Oj_Sorted_Find_OjMID,      Array_Binary_Find},
        {Oj_Push_OjMID,             Array_Push_Oj},
        {Oj_Push_Front_OjMID,       Array_Push_Front_Oj},
        {Oj_Count_OjMID,            Array_Count},
        {Oj_Pop_Npl_OjMID,          Array_Pop_Npl_Oj},
        {Oj_Pop_Front_Npl_OjMID,    Array_Pop_Front_Npl_Oj},
        {0}};
    YO_ARRAY *arr = Yo_Object(sizeof(YO_ARRAY),funcs);
    return arr;
  }
#endif
  ;

void *Array_Refs(void)
#ifdef _YO_ARRAY_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,         Array_Destruct},
        {Oj_Destruct_Element_OjMID, Yo_Unrefe},
        {Oj_Sort_OjMID,             Array_Sort},
        {Oj_Sorted_Insert_OjMID,    Array_Sorted_Insert},
        {Oj_Sorted_Find_OjMID,      Array_Binary_Find},
        {Oj_Push_OjMID,             Array_Push_Oj},
        {Oj_Pop_OjMID,              Array_Pop_Oj},
        {Oj_Push_Front_OjMID,       Array_Push_Front_Oj},
        {Oj_Pop_Front_OjMID,        Array_Pop_Front_Oj},
        {Oj_Count_OjMID,            Array_Count},
        {Oj_Pop_Npl_OjMID,          Array_Pop_Npl_Oj},
        {Oj_Pop_Front_Npl_OjMID,    Array_Pop_Front_Npl_Oj},
        {0}};
    YO_ARRAY *arr = Yo_Object(sizeof(YO_ARRAY),funcs);
    return arr;
  }
#endif
  ;

void *Array_Refs_Copy(void *refs, int count)
#ifdef _YO_ARRAY_BUILTIN
  {
    YO_ARRAY *arr = Array_Refs();
    int i;
    Array_Fill(arr,0,0,count);
    for ( i = 0; i < count; ++i )
      arr->at[i] = __Refe(((void**)refs)[i]);
    return arr;
  }
#endif
  ;
  
void *Array_Ptrs(void)
#ifdef _YO_ARRAY_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,         Array_Destruct},
        {Oj_Destruct_Element_OjMID, free},
        {Oj_Sort_OjMID,             Array_Sort},
        {Oj_Sorted_Insert_OjMID,    Array_Sorted_Insert},
        {Oj_Sorted_Find_OjMID,      Array_Binary_Find},
        {Oj_Push_OjMID,             Array_Push_Oj},
        {Oj_Pop_OjMID,              Array_Pop_Oj},
        {Oj_Push_Front_OjMID,       Array_Push_Front_Oj},
        {Oj_Pop_Front_OjMID,        Array_Pop_Front_Oj},
        {Oj_Count_OjMID,            Array_Count},
        {Oj_Pop_Npl_OjMID,          Array_Pop_Npl_Oj},
        {Oj_Pop_Front_Npl_OjMID,    Array_Pop_Front_Npl_Oj},
        {0}};
    YO_ARRAY *arr = Yo_Object(sizeof(YO_ARRAY),funcs);
    return arr;
  }
#endif
  ;

void *Array_Pchars(void)
#ifdef _YO_ARRAY_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,         Array_Destruct},
        {Oj_Destruct_Element_OjMID, free},
        {Oj_Compare_Elements_OjMID, strcmp},
        {Oj_Sort_OjMID,             Array_Sort},
        {Oj_Sorted_Insert_OjMID,    Array_Sorted_Insert},
        {Oj_Sorted_Find_OjMID,      Array_Binary_Find},
        {Oj_Push_OjMID,             Array_Push_Oj},
        {Oj_Pop_OjMID,              Array_Pop_Oj},
        {Oj_Push_Front_OjMID,       Array_Push_Front_Oj},
        {Oj_Pop_Front_OjMID,        Array_Pop_Front_Oj},
        {Oj_Count_OjMID,            Array_Count},
        {Oj_Pop_Npl_OjMID,          Array_Pop_Npl_Oj},
        {Oj_Pop_Front_Npl_OjMID,    Array_Pop_Front_Npl_Oj},
        {0}};
    YO_ARRAY *arr = Yo_Object(sizeof(YO_ARRAY),funcs);
    return arr;
  }
#endif
  ;

#ifdef _YO_ARRAY_BUILTIN
int __wcscmp(void *a, void *b) { return wcscmp(a,b); }
#endif

void *Array_Pwide(void)
#ifdef _YO_ARRAY_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,         Array_Destruct},
        {Oj_Destruct_Element_OjMID, free},
        {Oj_Compare_Elements_OjMID, __wcscmp},
        {Oj_Sort_OjMID,             Array_Sort},
        {Oj_Sorted_Insert_OjMID,    Array_Sorted_Insert},
        {Oj_Sorted_Find_OjMID,      Array_Binary_Find},
        {Oj_Push_OjMID,             Array_Push_Oj},
        {Oj_Pop_OjMID,              Array_Pop_Oj},
        {Oj_Push_Front_OjMID,       Array_Push_Front_Oj},
        {Oj_Pop_Front_OjMID,        Array_Pop_Front_Oj},
        {Oj_Count_OjMID,            Array_Count},
        {Oj_Pop_Npl_OjMID,          Array_Pop_Npl_Oj},
        {Oj_Pop_Front_Npl_OjMID,    Array_Pop_Front_Npl_Oj},
        {0}};
    YO_ARRAY *arr = Yo_Object(sizeof(YO_ARRAY),funcs);
    return arr;
  }
#endif
  ;

void *Array_Take_Data_Npl(YO_ARRAY *a)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *p = a->at;
    a->at = 0;
    a->capacity = a->count = 0;
    return p;
  }
#endif
  ;

#endif /* C_once_44A7F9A5_269A_48D5_AABB_F08291F9087B */

*/

#ifndef C_once_B4220D86_3019_4E13_8682_D7F809F4E829
#define C_once_B4220D86_3019_4E13_8682_D7F809F4E829

#ifdef _LIBYOYO
#define _YO_BINGINT_BUILTIN
#endif

#include "yoyo.hc"
#include "string.hc"
#include "buffer.hc"
#include "random.hc"

typedef struct _YO_BIGINT
  {
    unsigned short digits;
    signed char sign;
    unsigned char capacity; /* extra blocks count */
    halflong_t value[1];
  } YO_BIGINT;
  
enum
  {
    YO_BIGINT_BLOCKSIZE   = 128,
    YO_BIGINT_BLOCKMASK   = YO_BIGINT_BLOCKSIZE-1,
    YO_BIGINT_MINDIGITS   = (YO_BIGINT_BLOCKSIZE-sizeof(YO_BIGINT))/sizeof(halflong_t)+1, 
    YO_BIGINT_BLKDIGITS   = YO_BIGINT_BLOCKSIZE/sizeof(halflong_t), 
    SizeOf_Min_YO_BIGINT  = sizeof(YO_BIGINT)+(YO_BIGINT_MINDIGITS-1)*sizeof(halflong_t),
    YO_BIGINT_DIGIT_SHIFT = sizeof(halflong_t)*8,
    YO_BIGINT_DIGIT_MASK  = (halflong_t)-1L,
  };

typedef struct _YO_BIGINT_STATIC
  {
    YO_BIGINT bint;
    halflong_t space[YO_BIGINT_MINDIGITS-1];
  } YO_BIGINT_STATIC;

#define Bigint_Size_Of_Digits(Digits) (((((Digits)-1)*sizeof(halflong_t)+sizeof(YO_BIGINT))+YO_BIGINT_BLOCKMASK)&~YO_BIGINT_BLOCKMASK)
#define Bigint_Digits_Of_Bits(Bits) (((Bits)+sizeof(halflong_t)*8-1)/(sizeof(halflong_t)*8))
#define Bigint_Digits_Of_Bytes(Bytes) (((Bytes)+sizeof(halflong_t)-1)/sizeof(halflong_t))

#define Bigint_Init(Value) Bigint_Init_Digits(Value,1)
YO_BIGINT *Bigint_Init_Digits(quad_t val, int digits)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i = 0;
    YO_BIGINT *bint;
    if ( digits < YO_BIGINT_MINDIGITS ) digits = YO_BIGINT_MINDIGITS;
    bint = __Malloc(Bigint_Size_Of_Digits(digits));
    if ( val < 0 ) { bint->sign = -1; val = -val; } else bint->sign = 1;
    while ( val & YO_BIGINT_DIGIT_MASK )
     {
       bint->value[i++] = val & YO_BIGINT_DIGIT_MASK;
       val >>= YO_BIGINT_DIGIT_SHIFT; 
     }
    if ( i < digits )
      memset(bint->value+i,0,(digits-i)*sizeof(halflong_t));
    bint->digits = Yo_MAX(i,1);
    bint->capacity = ((digits-YO_BIGINT_MINDIGITS)+YO_BIGINT_BLKDIGITS-1)/YO_BIGINT_BLKDIGITS;
    return bint;
  }
#endif
  ;

int Bigint_Bitcount(YO_BIGINT *bint) 
#ifdef _YO_BINGINT_BUILTIN
  {
    int bc,bcc;
    int i = bint->digits - 1;
    while ( i >= 0 && !bint->value[i] ) --i;
    if ( i < 0 ) return 0;
    bc = Bitcount_Of(bint->value[i]);
    bcc = bc + i*YO_BIGINT_DIGIT_SHIFT;   
    return bcc;
  }
#endif
  ;
  
int Bigint_Is_1(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i;
    if ( bint->value[0] != 1 )
      return 0;
    for ( i = 1; i < bint->digits; ++i )
      if ( bint->value[i] ) 
        return 0;
    return 1;
  }
#endif
  ;

int Bigint_Is_0(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i = 0;
    for ( ; i < bint->digits; ++i )
      if ( bint->value[i] ) 
        return 0;
    return 1;
  }
#endif
  ;

#define Bigint_Copy(Bint) Bigint_Copy_Expand(Bint,0)
YO_BIGINT *Bigint_Copy_Expand(YO_BIGINT *bint, int extra_digits)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *out = 0;
    int digits, gap;
    
    STRICT_REQUIRE( extra_digits >= 0 );

    if ( bint )
      {
        digits = bint->digits+extra_digits;
        STRICT_REQUIRE( bint->digits > 0 );
      }
    else
      digits = extra_digits;
    
    if ( digits <= YO_BIGINT_MINDIGITS ) 
      gap = 0;
    else
      gap = digits-YO_BIGINT_MINDIGITS;
    
    out = __Malloc(Bigint_Size_Of_Digits(digits));
    memset(out,0,Bigint_Size_Of_Digits(digits));
    if ( bint )
      memcpy(out,bint,sizeof(*bint)+((bint->digits-1)*sizeof(halflong_t)));
    else
      out->sign = 1;
      
    out->digits = digits;
    out->capacity = (gap+YO_BIGINT_BLKDIGITS-1)/YO_BIGINT_BLKDIGITS;
    
    return out;
  }
#endif
  ;

YO_BIGINT *Bigint_Expand(YO_BIGINT *bint, int extra_digits)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( bint )
      {
        int digits = bint->digits+extra_digits;
    
        STRICT_REQUIRE( bint );
        STRICT_REQUIRE( bint->digits > 0 );
        STRICT_REQUIRE( extra_digits >= 0 );
    
        if ( bint->capacity*YO_BIGINT_BLKDIGITS + YO_BIGINT_MINDIGITS >= digits )
          {
            memset(bint->value+bint->digits,0,extra_digits*sizeof(halflong_t));
            bint->digits = digits;
            return bint;
          }
      }
    
    return Bigint_Copy_Expand(bint,extra_digits);
  }
#endif
  ;
  
YO_BIGINT *Bigint_Expand_If_Small(YO_BIGINT *bint, int required)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( !bint )
      return Bigint_Copy_Expand(0,required);
    else if ( bint->digits < required )
      return Bigint_Expand(bint,required - bint->digits);
    else
      return bint;
  }
#endif
  ;
  
#define Bigint_Alloca(Digits) Bigint_Setup_(alloca(Bigint_Size_Of_Digits(Digits)), Digits)
YO_BIGINT *Bigint_Setup_(YO_BIGINT *bint, int digits)
#ifdef _YO_BINGINT_BUILTIN
  {
    REQUIRE(bint);
    
    memset(bint,0,Bigint_Size_Of_Digits(digits));
    bint->digits = 1;
    bint->sign = 1;
    if ( digits > YO_BIGINT_MINDIGITS )
      bint->capacity =  ((digits-YO_BIGINT_MINDIGITS)+YO_BIGINT_BLKDIGITS-1)/YO_BIGINT_BLKDIGITS;
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Copy_To(YO_BIGINT *bint, YO_BIGINT *dst)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( dst->digits < bint->digits )
      dst = Bigint_Expand(dst,bint->digits-dst->digits);
    memcpy(dst->value,bint->value,sizeof(halflong_t)*bint->digits);
    dst->digits = bint->digits;
    dst->sign   = bint->sign;
    return dst;
  }
#endif
  ;

#define Bigint_Less(Bint,Q)  ( Bigint_Cmp(Bint,Q) <  0 )
#define Bigint_Equal(Bint,Q) ( Bigint_Cmp(Bint,Q) == 0 )
long Bigint_Cmp(YO_BIGINT *bint, YO_BIGINT *q)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( bint != q )
      {
        int ac  = bint->digits;
        int bc  = q->digits;
        halflong_t *a = bint->value+(ac-1); 
        halflong_t *b = q->value+(bc-1); 

      }
      
    return 0;
  }
#endif
  ;

YO_BIGINT *Bigint_Mul_Short(YO_BIGINT *bint,halflong_t d)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i,j;
    ulong_t Q = 0;
    ulong_t C = 0;

    for ( i = 0, j = bint->digits; i < j; ++i )
      {
        Q = (ulong_t)bint->value[i] * (ulong_t)d + Q;
        C = (Q & YO_BIGINT_DIGIT_MASK) + C;
        bint->value[i] = (halflong_t)C;
        Q >>= YO_BIGINT_DIGIT_SHIFT;
        C >>= YO_BIGINT_DIGIT_SHIFT;
      }

    if ( Q )
      {
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[i] = (halflong_t)Q;
      }
      
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Add_Short(YO_BIGINT *bint,halflong_t d)
#ifdef _YO_BINGINT_BUILTIN
  {
    halflong_t *i, *iE;
    ulong_t Q = (ulong_t)bint->value[0]+d;
    
    bint->value[0] = (halflong_t)Q;
    Q >>= YO_BIGINT_DIGIT_SHIFT;

    if ( Q )
      for ( i = bint->value+1, iE = bint->value+bint->digits; i < iE && Q; ++i )
        {
          Q += (ulong_t)*i;
          *i = (halflong_t)Q;
          Q >>= YO_BIGINT_DIGIT_SHIFT;
        }

    if ( Q )
      {
        int j = i-bint->value;
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[j] = (halflong_t)Q;
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Sub_Short(YO_BIGINT *bint,halflong_t d)
#ifdef _YO_BINGINT_BUILTIN
  {
    halflong_t *i, *iE;
    ulong_t Q;
    
    if ( bint->sign < 1 ) return Bigint_Add_Short(bint,d);
    
    Q = (ulong_t)bint->value[0]-d;
    bint->value[0] = (halflong_t)Q;

    Q = ( Q >> YO_BIGINT_DIGIT_SHIFT ) & 1;

    if ( Q )
      for ( i = bint->value+1, iE = bint->value+bint->digits; i < iE && Q; ++i )
        {
          Q = (ulong_t)*i;
          --Q;
          *i = (halflong_t)Q;
          Q = ( Q >> YO_BIGINT_DIGIT_SHIFT ) & 1;
        }

    if ( Q )
      {
        int j;
        bint->sign = -bint->sign;
        for ( j = 0; j < bint->digits; ++j )
          bint->value[j] = ~bint->value[j];
        bint = Bigint_Add_Short(bint,1);
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Reset(YO_BIGINT *bint,int digits)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( !bint )
      bint = Bigint_Expand(bint,digits);
    else
      {
        if ( digits > bint->digits && digits > YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,digits-bint->digits);
        else
          bint->digits = Yo_MAX(digits,1);
      }
    
    memset(bint->value,0,sizeof(halflong_t)*bint->digits);
    return bint;
  }
#endif
  ;

#define Bigint_Bit(Bint,i) \
  (((Bint)->value[i/YO_BIGINT_DIGIT_SHIFT] >> (i%YO_BIGINT_DIGIT_SHIFT)) & 1 )
#define Bigint_Setbit_(p,val) (p) = ((p)&~(val))|(val)
#define Bigint_Setbit(Bint,i,val) Bigint_Setbit_(\
    (Bint)->value[i/YO_BIGINT_DIGIT_SHIFT],\
    (val&1) << (i%YO_BIGINT_DIGIT_SHIFT))

YO_BIGINT *Bigint_Hishift_Q(YO_BIGINT *bint,YO_BIGINT *lo,int count,int *bits)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i = *bits-1, j;
    bint = Bigint_Reset(bint,(count+YO_BIGINT_DIGIT_SHIFT-1)/YO_BIGINT_DIGIT_SHIFT);
    
    count = Yo_MIN(count,*bits);
    *bits -= count;
    
    for ( j = count-1 ; j >= 0 ; --j, --i ) 
      {
        halflong_t d = lo->value[i/YO_BIGINT_DIGIT_SHIFT];
        d >>= (i%YO_BIGINT_DIGIT_SHIFT);
        bint->value[j/YO_BIGINT_DIGIT_SHIFT] |= ( (d&1) << (j%YO_BIGINT_DIGIT_SHIFT));
      }
      
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Hishift_1(YO_BIGINT *bint, YO_BIGINT *lo,int *bits)
#ifdef _YO_BINGINT_BUILTIN
  {
    halflong_t Q = 0;
    halflong_t *i, *iE;
    
    if ( *bits )
      {
        --*bits;
        Q = Bigint_Bit(lo,*bits);
      }

    for ( i = bint->value, iE = bint->value+bint->digits; i != iE; ++i )
      {
        halflong_t S = *i;
        *i = ( S << 1 ) | Q;
        Q = S >> (YO_BIGINT_DIGIT_SHIFT-1);
      }

    if ( Q )
      {
        int j = bint->digits;
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[j] = (halflong_t)Q;
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Lshift_1(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    halflong_t *i, *iE;
    halflong_t Q = 0;

    for ( i = bint->value, iE = bint->value+bint->digits; i != iE; ++i )
      {
        halflong_t k = *i;
        *i = ( k << 1 ) | Q;
        Q = k >> (YO_BIGINT_DIGIT_SHIFT-1);
      }

    if ( Q )
      {
        int j = bint->digits;
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[j] = (halflong_t)Q;
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Rshift_1(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    halflong_t *i, *iE;
    halflong_t Q = 0;

    for ( i = bint->value+bint->digits-1, iE = bint->value-1; i != iE; --i )
      {
        halflong_t k = *i;
        *i = ( k >> 1 ) | Q;
        Q = k << (YO_BIGINT_DIGIT_SHIFT-1);
      }
    
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Lshift(YO_BIGINT *bint,unsigned count)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i, dif;
    int w = count%YO_BIGINT_DIGIT_SHIFT;
    ulong_t Q = 0;

    if ( w ) for ( i = 0; i < bint->digits; ++i )
      {
        Q |= ((ulong_t)bint->value[i]<<w);
        bint->value[i] = (halflong_t)Q;
        Q = (Q>>YO_BIGINT_DIGIT_SHIFT);
      }
      
    if ( Q )
      {
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[i] = (halflong_t)Q;
      }

    dif = count/YO_BIGINT_DIGIT_SHIFT;
    if ( dif ) 
      {
        int digits = bint->digits;
        if ( digits+dif > YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,dif);
        else bint->digits += dif;
        memmove(bint->value+dif,bint->value,digits*sizeof(halflong_t));
        memset(bint->value,0,dif*sizeof(halflong_t));
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Rshift(YO_BIGINT *bint,unsigned count)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i, dif;
    int w = count%YO_BIGINT_DIGIT_SHIFT;

    bint->value[0] = bint->value[0] >> w;
    
    if ( w ) for ( i = 1; i < bint->digits; ++i )
      {
        halflong_t Q = bint->value[i];
        bint->value[i-1] |= Q << (YO_BIGINT_DIGIT_SHIFT-w);
        bint->value[i] = Q >> w;
      }
        
    dif = count/YO_BIGINT_DIGIT_SHIFT;
    if ( dif )
      {
        int j = Yo_MAX(bint->digits-dif,0);
        if ( j )
          memmove(bint->value,bint->value+dif,j*sizeof(halflong_t));
        memset(bint->value+j,0,(bint->digits-j)*sizeof(halflong_t));
        bint->digits = Yo_MAX(j,1);
      }

    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Sub_Unsign(YO_BIGINT *bint,YO_BIGINT *q,int sign)
#ifdef _YO_BINGINT_BUILTIN
  {
    ulong_t Q;
    int i,j;

    if ( bint->digits < q->digits )
      if ( q->digits > YO_BIGINT_MINDIGITS )
        bint = Bigint_Expand(bint,q->digits);
      else
        {
          memset(bint->value+bint->digits,0,sizeof(halflong_t)*(q->digits-bint->digits));
          bint->digits = q->digits;
        }
    
    Q = 0;
    for ( i = 0, j = q->digits; i < j; ++i )
      {
        Q = (ulong_t)bint->value[i] - (ulong_t)q->value[i] - Q;
        bint->value[i] = (halflong_t)Q;
        Q >>= YO_BIGINT_DIGIT_SHIFT;
        Q &= 1;
      };

    for ( ; Q && i < bint->digits; ++i )
      {
        Q = (ulong_t)bint->value[i] - Q;
        bint->value[i] = (halflong_t)Q;
        Q >>= YO_BIGINT_DIGIT_SHIFT;
        Q &= 1;
      }
      
    if ( Q )
      {
        bint->sign = -sign;
        for ( i = 0, j = bint->digits; i < j; ++i )
          bint->value[i] = ~bint->value[i];
        Bigint_Add_Short(bint,1);
      }
    else
      bint->sign = sign;
      
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Add_Unsign(YO_BIGINT *bint,YO_BIGINT *q,int sign)
#ifdef _YO_BINGINT_BUILTIN
  {
    ulong_t Q;
    int i,j;
    
    if ( bint->digits < q->digits )
      if ( q->digits > YO_BIGINT_MINDIGITS )
        bint = Bigint_Expand(bint,q->digits);
      else
        {
          memset(bint->value+bint->digits,0,sizeof(halflong_t)*(q->digits-bint->digits));
          bint->digits = q->digits;
        }
    
    Q = 0;
    for ( i = 0, j = q->digits; i < j; ++i )
      {
        Q = (ulong_t)bint->value[i] + (ulong_t)q->value[i] + Q;
        bint->value[i] = (halflong_t)Q;
        Q >>= YO_BIGINT_DIGIT_SHIFT;
      };

    for ( ; Q && i < bint->digits; ++i )
      {
        Q = (ulong_t)bint->value[i] + Q;
        bint->value[i] = (halflong_t)Q;
        Q >>= YO_BIGINT_DIGIT_SHIFT;
      }
      
    if ( Q )
      {
        if ( bint->digits >= YO_BIGINT_MINDIGITS )
          bint = Bigint_Expand(bint,1);
        else ++bint->digits;
        bint->value[i] = (halflong_t)Q;
      }

    bint->sign = sign;
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Sub(YO_BIGINT *bint,YO_BIGINT *q)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( bint->sign != q->sign )
      return Bigint_Add_Unsign(bint,q,-q->sign);
    else
      return Bigint_Sub_Unsign(bint,q,q->sign);
  }
#endif
  ;

YO_BIGINT *Bigint_Add(YO_BIGINT *bint,YO_BIGINT *q)
#ifdef _YO_BINGINT_BUILTIN
  {
    if ( bint->sign != q->sign )
      return Bigint_Sub_Unsign(bint,q,-q->sign);
    else
      return Bigint_Add_Unsign(bint,q,q->sign);
  }
#endif
  ;

#define Bigint_Div(Bint,Q) Bigint_Divrem(Bint,Q,0)
YO_BIGINT *Bigint_Divrem(YO_BIGINT *bint, YO_BIGINT *q, YO_BIGINT **rem)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *R, *Q = Bigint_Init(0);
    int bits    = Bigint_Bitcount(bint);
    int divbits = Bigint_Bitcount(q);
  
    if ( divbits > bits ) 
      {
        if ( rem ) *rem = Bigint_Copy(bint);
        return Q;
      }
  
    if ( !divbits ) 
      __Raise(YO_ERROR_ZERODIVIDE,0);
      
    R = Bigint_Init(0);
    Q = Bigint_Hishift_Q(Q,bint,divbits,&bits);
  
    for(;;) 
      {
        if ( !Bigint_Less(Q,q) )

    if ( rem ) *rem = Q;
    return R;
  }
#endif
  ;
  
YO_BIGINT *Bigint_Divrem_Short(YO_BIGINT *bint, halflong_t q, halflong_t *rem)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i;
    ulong_t Q = 0;
    for ( i = bint->digits-1; i >= 0; --i )
      {
        Q <<= YO_BIGINT_DIGIT_SHIFT;
        Q |= bint->value[i];
        bint->value[i] = (halflong_t)(Q/q);
        Q = Q%q;
      }
    if ( rem ) *rem = (halflong_t)Q;
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Decode_2(char *S)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *bint = Bigint_Init(0);
    char *p = S;
    
    __Auto_Ptr(bint)
      if ( p )
        {
          for ( ;*p; ++p )
            {
              if ( *p != '0' && *p != '1' ) __Raise_Format(YO_ERROR_ILLFORMED,("invalid binary number %s",S));
              bint = Bigint_Lshift_1(bint);
              bint->value[0] |= (byte_t)(*p-'0');
            }
        }
    
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Decode_10(char *S)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *bint = Bigint_Init(0);
    char *p = S;
    
    __Auto_Ptr(bint)
      if ( p )
        {
          if ( *p == '-' ) { bint->sign = -1; ++p; }
          else if ( *p == '+' ) ++p;
          
          for ( ;*p; ++p )
            {
              if ( !Isdigit(*p) ) __Raise_Format(YO_ERROR_ILLFORMED,("invalid decimal number %s",S));
              bint = Bigint_Mul_Short(bint,10);
              bint = Bigint_Add_Short(bint,*p-'0');
            }
        }
    
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Decode_16(char *S)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *bint = Bigint_Init(0);
    char *p = S;
    
    __Auto_Ptr(bint)
      if ( p )
        {
          for ( ;*p; ++p )
            {
              if ( !Isxdigit(*p) || !Isxdigit(p[1]) ) 
                __Raise_Format(YO_ERROR_ILLFORMED,("invalid hexadecimal number %s",S));
              bint = Bigint_Lshift(bint,8);
              bint->value[0] |= Str_Unhex_Byte(p,0,0);
              ++p;
            }
        }
    
    return bint;
  }
#endif
  ;

char *Bigint_Encode_2(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    char *ret = 0;
    __Auto_Ptr(ret)
      {
        int i = 0, bc = Bigint_Bitcount(bint);
        char *S = __Malloc(bc+1);
        
        S[bc] = 0;
        
        if ( bc ) for ( ; i < bc; ++i )
          S[i] = Bigint_Bit(bint,i) ? '1' : '0';
        
        ret = Str_Reverse(S,bc);
      }
    return ret;
  }
#endif
  ;

char *Bigint_Encode_10(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    char *ret = 0;
    __Auto_Ptr(ret)
      {
        YO_BUFFER *bf = Buffer_Init(0);
        YO_BIGINT *R = Bigint_Copy(bint);

        if ( !Bigint_Is_0(R) )
          {
            do
              {
                halflong_t rem;
                R = Bigint_Divrem_Short(R,10,&rem);

        ret = Str_Reverse(bf->at,bf->count);
      }
    return ret;
  }
#endif
  ;

char *Bigint_Encode_16(YO_BIGINT *bint)
#ifdef _YO_BINGINT_BUILTIN
  {
    char *ret = 0;
    __Auto_Ptr(ret)
      {
        int bc = (Bigint_Bitcount(bint)+7)/8;
        char *S = Str_Hex_Encode(bint->value,bc);
        ret = Str_Reverse(S,bc*2);
      }
    return ret;
  }
#endif
  ;

YO_BIGINT *Bigint_Mul(YO_BIGINT *bint, YO_BIGINT *d)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *R = Bigint_Alloca(bint->digits+d->digits+1);
    int i, Qdigi, j, Tdigi;

    R->digits = bint->digits+d->digits+1;

    for ( i = 0, Qdigi = d->digits, Tdigi = bint->digits; i < Qdigi; ++i )
      {
        ulong_t Q = 0;
        ulong_t C = 0;
        for ( j = 0; j < Tdigi; ++j )
          {
            Q = (ulong_t)d->value[i] * (ulong_t)bint->value[j] + Q;
            C = (ulong_t)R->value[j+i] + (Q & YO_BIGINT_DIGIT_MASK) + C;
            R->value[j+i] = (halflong_t)C;
            Q >>=YO_BIGINT_DIGIT_SHIFT;
            C >>= YO_BIGINT_DIGIT_SHIFT;
          }
        do 
          {
            C = (ulong_t)R->value[Tdigi+i] + (Q & YO_BIGINT_DIGIT_MASK) + C;
            R->value[Tdigi+i] = (halflong_t)C;
            Q >>= YO_BIGINT_DIGIT_SHIFT;
            C >>= YO_BIGINT_DIGIT_SHIFT;
          }
        while ( i < Qdigi && C ); 
      }

    while ( R->digits > 1 && !R->value[R->digits-1] ) --R->digits;
    if ( d->sign != bint->sign ) R->sign = -1;
    return Bigint_Copy_To(R,bint);
  }
#endif
  ;
  
YO_BIGINT *Bigint_Modulo(YO_BIGINT *bint, YO_BIGINT *mod)
#ifdef _YO_BINGINT_BUILTIN
  {
    int bits = Bigint_Bitcount(bint);
    int modbits = Bigint_Bitcount(mod);
    YO_BIGINT *R = Bigint_Alloca(mod->digits+1);
    
    if ( modbits > bits ) return bint;
    
    R = Bigint_Hishift_Q(R,bint,modbits,&bits);
    
    for(;;) 
      {

      }
    
    return Bigint_Copy_To(R,bint);
  }
#endif
  ;

YO_BIGINT *Bigint_Modmul(YO_BIGINT *bint, YO_BIGINT *d, YO_BIGINT *mod)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *R = Bigint_Alloca(bint->digits+d->digits+1);
    int i, Qdigi, j, Tdigi;
    int bits, modbits;
    R->digits = bint->digits+d->digits+1;

    for ( i = 0, Qdigi = d->digits, Tdigi = bint->digits; i < Qdigi; ++i )
      {
        ulong_t Q = 0;
        ulong_t C = 0;
        for ( j = 0; j < Tdigi; ++j )
          {
            Q = (ulong_t)d->value[i] * (ulong_t)bint->value[j] + Q;
            C = (ulong_t)R->value[j+i] + (Q & YO_BIGINT_DIGIT_MASK) + C;
            R->value[j+i] = (halflong_t)C;
            Q >>=YO_BIGINT_DIGIT_SHIFT;
            C >>= YO_BIGINT_DIGIT_SHIFT;
          }
        do 
          {
            C = (ulong_t)R->value[Tdigi+i] + (Q & YO_BIGINT_DIGIT_MASK) + C;
            R->value[Tdigi+i] = (halflong_t)C;
            Q >>= YO_BIGINT_DIGIT_SHIFT;
            C >>= YO_BIGINT_DIGIT_SHIFT;
          }
        while ( i < Qdigi && C ); 
      }

    while ( R->digits > 1 && !R->value[R->digits-1] ) --R->digits;
    if ( d->sign != bint->sign ) R->sign = -1;

      }
    
    return bint;
  }
#endif
  ;

YO_BIGINT *Bigint_Expmod(YO_BIGINT *bint, YO_BIGINT *e,YO_BIGINT *mod)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *E = Bigint_Alloca(e->digits);
    YO_BIGINT *t = Bigint_Alloca(mod->digits);
    YO_BIGINT *R = 0;
    
    __Auto_Ptr(R)
      {
        E = Bigint_Copy_To(e,E);
        t = Bigint_Modulo(Bigint_Copy_To(bint,t),mod);
        R = bint;
        R->value[0] = 1;

      }
      
    return R;
  }
#endif
  ;

YO_BIGINT *Bigint_Invmod(YO_BIGINT *bint, YO_BIGINT *mod)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *i = 0;
    
    __Auto_Ptr(i)
      {
        YO_BIGINT *b = Bigint_Copy(mod);
        YO_BIGINT *j = Bigint_Init(1);
        YO_BIGINT *c = Bigint_Copy(bint);
        i = Bigint_Init(0);
    
        while ( c->value[0] || !Bigint_Is_0(c) )
          {
            YO_BIGINT *y;
            YO_BIGINT *q;
            YO_BIGINT *x;
            x = Bigint_Divrem(b,c,&y);
            b = c;
            c = y;
            q = Bigint_Sub(i,Bigint_Mul(Bigint_Copy(j),x));
            i = j;
            j = q;
          }
      
        if ( i->sign < 0 ) i = Bigint_Add(i,mod);
      }
    
    return i;
  }
#endif
  ;

#ifndef _YO_BINGINT_BUILTIN
extern
#endif
unsigned short First_Prime_Values[]
#ifdef _YO_BINGINT_BUILTIN
= {
#include "prime_values.inc"        
}
#endif
  ;

#ifndef _YO_BINGINT_BUILTIN
extern
#endif
int First_Prime_Values_Count
#ifdef _YO_BINGINT_BUILTIN
= sizeof(First_Prime_Values)/sizeof(First_Prime_Values[0])
#endif
  ;

#ifdef _YO_BINGINT_BUILTIN
enum 
  { 
    YO_PRIME_MAX_COUNT = /*1229*/ sizeof(First_Prime_Values)/sizeof(First_Prime_Values[0]),
    YO_PRIME_RSAPUBLIC_MIN = 256, 
    YO_PRIME_RSAPUBLIC_MAX = YO_PRIME_MAX_COUNT,
    YO_PRIME_TEST_Q = 32,
  };
#endif

halflong_t First_Prime(int no)
#ifdef _YO_BINGINT_BUILTIN
  {
    STRICT_REQUIRE(no >= 0 && no < YO_PRIME_MAX_COUNT);
    return First_Prime_Values[no];
  }
#endif
  ;

int Bigint_Ferma_Prime_Test(YO_BIGINT *bint, int q)
#ifdef _YO_BINGINT_BUILTIN
  {
    int is_prime = 1;
    __Auto_Release
      {
        int i;
        YO_BIGINT *p   = Bigint_Alloca(bint->digits);
        YO_BIGINT *p_1 = Bigint_Alloca(bint->digits);
        YO_BIGINT *t   = Bigint_Alloca(1);
    
        if ( !q ) q = YO_PRIME_TEST_Q;
        STRICT_REQUIRE( q > 0 && q < YO_PRIME_MAX_COUNT );

        p = Bigint_Copy_To(bint,p);
        p_1 = Bigint_Sub_Short(Bigint_Copy_To(bint,p_1),1);

        for ( i =0; is_prime && i < q; ++i )
          {
            t->value[0] = First_Prime_Values[i];
            t->digits = 1;
            if ( ! Bigint_Is_1(Bigint_Expmod(t,p_1,p)) )
              is_prime = 0;
          }
      }
      
    return is_prime;
  }
#endif
  ;

YO_BIGINT *Bigint_Prime(int bits, int q, int maxcount,YO_BIGINT *tmp)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i,n;
    YO_BIGINT *ret = 0;
    YO_BIGINT *r = tmp;
    
    if ( !q ) q = YO_PRIME_TEST_Q;
    if ( !maxcount ) maxcount = 101;
    
    STRICT_REQUIRE( maxcount > 0 );
    STRICT_REQUIRE( bits > 8 );
    STRICT_REQUIRE( q > 0 && q < 500 );

    n = Yo_MIN(128,bits-3);

                break;
              }
            r = Bigint_Add_Short(r,2);
          }
       }
     
    if ( !ret )
      __Raise(YO_ERROR_LIMIT_REACHED,"failed to generate prime");
    return ret;
  }
#endif
  ;
  
void Bigint_Generate_Rsa_PQ(
  YO_BIGINT /*out*/ **rsa_P, int pBits,
  YO_BIGINT /*out*/ **rsa_Q, int qBits,
  YO_BIGINT /*out*/ **rsa_N)
#ifdef _YO_BINGINT_BUILTIN
  {
    int lt = 0;
    int bits = qBits+pBits-1;
    YO_BIGINT *nMax = Bigint_Init(1);
    YO_BIGINT *nMin = Bigint_Init(1);
    YO_BIGINT *n, *p, *q;
    YO_BIGINT *pr = Bigint_Alloca(Bigint_Digits_Of_Bits(pBits)+1);
    YO_BIGINT *qr = Bigint_Alloca(Bigint_Digits_Of_Bits(qBits)+1);
    YO_BIGINT *nr = Bigint_Alloca(Bigint_Digits_Of_Bits(bits)+1);

    nMax = Bigint_Sub_Short(Bigint_Lshift(nMax,bits),1);
    nMin = Bigint_Lshift(nMin,bits-1);

    REQUIRE(bits >= 33);
    STRICT_REQUIRE(pBits > 0);
    STRICT_REQUIRE(qBits > 0);

    *rsa_P = (p == pr) ? Bigint_Copy(p) : p;
    *rsa_Q = (q == qr) ? Bigint_Copy(q) : q; 
    *rsa_N = (n == nr) ? Bigint_Copy(n) : n;
  }
#endif
  ;

YO_BIGINT *Bigint_Mutal_Prime(YO_BIGINT *bint, int bits)
#ifdef _YO_BINGINT_BUILTIN
  {
    YO_BIGINT *ret = 0;
    YO_BIGINT *r = Bigint_Alloca(Bigint_Digits_Of_Bits(bits)+1);
    YO_BIGINT *d = Bigint_Alloca(bint->digits);
    while (!ret) __Auto_Ptr(ret)
      {
        YO_BIGINT *x = Bigint_Prime(bits,0,0,r);
        Bigint_Copy_To(bint,d);
        if ( !Bigint_Is_0(Bigint_Modulo(d,x)) )
          ret = (x == r) ? Bigint_Copy(x) : x;
      }
    return ret;
  }
#endif
  ;
  
YO_BIGINT *Bigint_First_Mutal_Prime(YO_BIGINT *bint, int skip_primes)
#ifdef _YO_BINGINT_BUILTIN
  {
    int i;
    halflong_t rem = 0;
    halflong_t prime;
    YO_BIGINT *r = Bigint_Alloca(bint->digits);
    
    REQUIRE(skip_primes > 0 && skip_primes < YO_PRIME_MAX_COUNT/2 );
    
    for ( i = skip_primes; !rem && i < YO_PRIME_MAX_COUNT; ++i )
      {
        YO_BIGINT *x = Bigint_Copy_To(bint,r);
        prime = First_Prime_Values[i];
        Bigint_Divrem_Short(x,prime,&rem);
      }
    
    if ( rem )         
      return Bigint_Init(prime);
    
    return 0;      
  }
#endif
  ;

void Bigint_Generate_Rsa_Key_Pair(
  YO_BIGINT /*out*/ **rsa_pub, 
  YO_BIGINT /*out*/ **rsa_priv, 
  YO_BIGINT /*out*/ **rsa_mod,
  int bits)
#ifdef _YO_BINGINT_BUILTIN
  {
    __Auto_Ptr(*rsa_mod)
      {
        YO_BIGINT *p, *q, *n, *phi;
        int pBits = Get_Random(bits/5,bits/2);
        int qBits = (bits+1)-pBits;

        STRICT_REQUIRE(pBits < bits/2 && pBits > 0 );
        STRICT_REQUIRE(pBits+qBits == bits+1);

        n = 0;

    
    __Pool(*rsa_pub);
    __Pool(*rsa_priv);
  }
#endif
  ;

YO_BIGINT *Bigint_From_Bytes(YO_BIGINT *bint, void *data, int len)
#ifdef _YO_BINGINT_BUILTIN
  {
#if defined __i386 || defined __x86_64
    int digits = Bigint_Digits_Of_Bytes(len);
    bint = Bigint_Expand_If_Small(bint,digits);
    memset(bint->value,0,bint->digits*sizeof(halflong_t));
    memcpy(bint->value,data,len);
    return bint;
#else
  #error fixme!
#endif
  }
#endif
  ;
  
int Bigint_To_Bytes(YO_BIGINT *bint, void *out, int maxlen)
#ifdef _YO_BINGINT_BUILTIN
  {
#if defined __i386 || defined __x86_64
    int l = sizeof(halflong_t)*bint->digits;
    byte_t *p = (byte_t*)(bint->value+bint->digits) - 1;
    while ( p != (byte_t*)bint->value && !*p ) --l;
    if ( l > maxlen )
      __Raise(YO_ERROR_NO_ENOUGH,"raw bigint outbuffer to small!");
    memcpy(out,bint->value,l);
    return l;
#else
    #error fixme!
#endif
  }
#endif
  ;
  
#endif /* C_once_B4220D86_3019_4E13_8682_D7F809F4E829 */

*/

#ifndef C_once_91A90154_CD39_414F_9D05_4B45029B172F
#define C_once_91A90154_CD39_414F_9D05_4B45029B172F

#ifdef _LIBYOYO
#define _YO_BIO_BUILTIN
#endif

enum 
  { 
    YO_BIO_BUFFER_SIZE = 512,
    YO_BIO_WRITE = __FOUR_CHARS('W','R','I','T'), 
    YO_BIO_READ  = __FOUR_CHARS('R','E','A','D'),
  };

typedef struct _YO_BIO_BUFFER
  {
    int    start, end;
    byte_t data[YO_BIO_BUFFER_SIZE];
  } YO_BIO_BUFFER;

typedef struct _YO_BIO
  {
    YO_BIO_BUFFER bf;
    int (*inout)(void*,void*,int,int);
    void *strm;
    int  direction;
  } YO_BIO;

YO_BIO *Bio_Input(void *strm)
#ifdef _YO_BIO_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    YO_BIO_Destruct},
        {Oj_Read_OjMID,        Buffer_File_Read},
      };
    YO_BIO *bio = __Object(sizeof(YO_BIO),funcs);
    bio->direction = YO_BIO_READ;
    bio->inout = (int(*)(void*,void*,int,int))Yo_Find_Method_Of(&strm,Oj_Read_OjMID,YO_RAISE_ERROR)
    bio->strm = __Refe(strm);
    return bio;
  }
#endif  
  ;
  
YO_BIO *Bio_Output(void *strm)
#ifdef _YO_BIO_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    YO_BIO_Destruct},
        {Oj_Write_OjMID,       Bio_Write},
        {Oj_Flush_OjMID,       Bio_Flush},
      };
      
    YO_BIO *bio = __Object(sizeof(YO_BIO),funcs);
    bio->direction = YO_BIO_WRITE;
    bio->inout = (int(*)(void*,void*,int,int))Yo_Find_Method_Of(&strm,Oj_Write_OjMID,YO_RAISE_ERROR)
    bio->strm  = __Refe(strm);
    return bio;
  }
#endif  
  ;

void Bio_Flush(YO_BIO *bio)
#ifdef _YO_BIO_BUILTIN
  {
    /* output bio doesn´t use bf.start */
    if ( bio->direction != YO_BIO_WRITE )
      __Raise(YO_ERROR_UNSUPPORTED,__yoTa("input BIO doesn't support Flush"));
    if ( bio->bf.data )
      bio->inout(bio->strm,bio->bf.data,bio->bf.end);
    bio->bf.end = 0;
    Oj_Flush(bio->strm);
  }
#endif
  ;
  
int Bio_Write(YO_BIO *bio,void *dta,int count,int mincount)
#ifdef _YO_BIO_BUILTIN
  {
    /* output bio doesn´t use bf.start */
    int q,cc=0;
    
    if ( bio->direction != YO_BIO_WRITE )
      __Raise(YO_ERROR_UNSUPPORTED,__yoTa("input BIO doesn't support Write"));
    
    while ( cc != count )
      {
        q = Yo_MIN(count-cc,(sizeof(bio->bf.data)-bio->bf.end));
        
        if ( q )
          {

      }
       
    return cc;
  }
#endif
  ;

int _Bio_Fill_Buffer(YO_BIO *bio, int read_or_die)
#ifdef _YO_BIO_BUILTIN
  {
    bio->bf.start = 0;
    bio->bf.end = 0;
    q = bio->inout(bio->strm,bio->bf.data,sizeof(bio->bf.data),read_or_die?1:0);
    bio->bf.end = q;

    if ( !q && read_or_die ) 
      __Raise(YO_ERROR_UNEXPECTED,__yoTa("chained read should return least 1 byte or die!",0))
  }
#endif
  ;
  
int Bio_Read(YO_BIO *bio,void *out,int count,int mincount)
#ifdef _YO_BIO_BUILTIN
  {
    int q,cc = 0;
    if ( bio->direction != YO_BIO_READ )
      __Raise(YO_ERROR_UNSUPPORTED,__yoTa("output BIO doesn't support Read"));
    
    if ( !count ) return 0;
    
    while ( cc != count )
      {
        q = Yo_MIN(count-cc,(bio->bf.end-bio->bf.start));

      }
    
    return cc;
  }
#endif
  ;

char *Bio_Read_Line(YO_BIO *bio, YO_BUFFER *bf)
#ifdef _YO_BIO_BUILTIN
  {
    int i, E;
    YO_BUFFER *out = bf;
    if ( !out ) out  = Buffer_Init(0);
    out->count = 0;
    
    for(;;)
      {
        char *p;
        if ( bio->bf.end == bio->bf.start )

      }
    else
      return bf->at;
  }
#endif 
  ;

int Bio_Copy_Into(YO_BIO *bio, void *strm, int count)
#ifdef _YO_BIO_BUILTIN
  {
    byte_t bf[512];
    int i;
    int (*oj_read)(void*,void*,int,int) = 
      ((int(*)(void*,void*,int,int))Yo_Find_Method_Of(&strm,Oj_Read_OjMID,YO_RAISE_ERROR));
    for ( i = 0; i < count || count < 0; )
      {
        int l = oj_read(strm,bf,sizeof(bf),0);
        if ( l ) 
          {
            Bio_Write(bio,bf,l,l);
            i += l;
          }
        else if ( count < 0 )
          break;
        else
          __Raise(YO_ERROR_IO_EOF,__yoTa("stream out of data",0));
      }
    return i;
  }
#endif 
  ;

int Bio_Copy_From(YO_BIO *bio, void *strm, int count)
#ifdef _YO_BIO_BUILTIN
  {
    byte_t bf[512];
    int i;
    int (*oj_write)(void*,void*,int,int) = 
      ((int(*)(void*,void*,int,int))Yo_Find_Method_Of(&strm,Oj_Write_OjMID,YO_RAISE_ERROR));
    for ( i = 0; i < count || count < 0; )
      {
        int l = Bio_Read(bio,bf,sizeof(bf),0);
        if ( l ) 
          {
            oj_write(strm,bf,l,l);
            i += l;
          }
        else if ( count < 0 )
          break;
        else
          __Raise(YO_ERROR_IO_EOF,__yoTa("stream out of data",0));
      }
    return i;
  }
#endif 
  ;

void Bio_Reset(YO_BIO *bio)
#ifdef _YO_BIO_BUILTIN
  {
    bio->bf.start = bio->bf.end = 0;
  }
#endif 
  ;

#endif /* C_once_91A90154_CD39_414F_9D05_4B45029B172F */

*/

#ifndef C_once_A87E119A_8C55_442C_94CE_F1B2DF0121AD
#define C_once_A87E119A_8C55_442C_94CE_F1B2DF0121AD

#ifdef _LIBYOYO
#define _YO_BLOWFISH_BUILTIN
#endif

#include "yoyo.hc"
#include "cipher.hc"
#include "md5.hc"

typedef struct _YO_BLOWFISH
  {
    uint_t P[16 + 2];
    uint_t S[4][256];
  } YO_BLOWFISH;

#ifdef _YO_BLOWFISH_BUILTIN

static uint_t Blowfish_P[16 + 2] = 
  {
    0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
    0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
    0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
    0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,

      0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
      0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
      0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
      0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6 }
  };
#endif

#ifdef _YO_BLOWFISH_BUILTIN
#define F(S,X) \
      ((( (S)[0][((X) >> 24)] + (S)[1][(((X) >> 16)&0x0ff)] ) \
       ^ (S)[2][((X) >> 8)&0x0ff] ) \
       + (S)[3][(X) & 0x0ff])
#endif

void Blowfish_Encrypt8_(YO_BLOWFISH *self, uint_t *Lx, uint_t *Rx)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    uint_t  L = *Lx;
    uint_t  R = *Rx;
    uint_t  temp;
    int     i;
  
    for (i = 0; i < 16; ++i) 

    *Rx = R ^ self->P[16];
    *Lx = L ^ self->P[16 + 1];
  }
#endif
  ;

void Blowfish_Encrypt8(YO_BLOWFISH *self,void *block8)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    uint_t L = Four_To_Unsigned_BE((byte_t*)block8+0);
    uint_t R = Four_To_Unsigned_BE((byte_t*)block8+4);
    Blowfish_Encrypt8_(self,&L,&R);
    Unsigned_To_Four_BE(L,(byte_t*)block8+0);
    Unsigned_To_Four_BE(R,(byte_t*)block8+4);
  }
#endif
  ;

void Blowfish_Decrypt8_(YO_BLOWFISH *self, uint_t *Lx, uint_t *Rx)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    uint_t  L = *Lx;
    uint_t  R = *Rx;
    uint_t  temp;
    int     i;
    
    for (i = 16 + 1; i > 1; --i) 

    *Rx = R ^ self->P[1];
    *Lx = L ^ self->P[0];
  }
#endif
  ;

void Blowfish_Decrypt8(YO_BLOWFISH *self,void *block8)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    uint_t L = Four_To_Unsigned_BE((byte_t*)block8+0);
    uint_t R = Four_To_Unsigned_BE((byte_t*)block8+4);
    Blowfish_Decrypt8_(self,&L,&R);
    Unsigned_To_Four_BE(L,(byte_t*)block8+0);
    Unsigned_To_Four_BE(R,(byte_t*)block8+4);
  }
#endif
  ;

#ifdef _YO_BLOWFISH_BUILTIN
#undef F
#endif

void Blowfish_Destruct(YO_BLOWFISH *self)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    __Destruct(self);
  }
#endif
  ;

void *Blowfish_Init_Static(YO_BLOWFISH *self, void *key, int key_len) 
#ifdef _YO_BLOWFISH_BUILTIN
  {
    int i, j, k;
    uint_t data;
    uint_t L = 0, R = 0;

    key_len = Yo_MIN(key_len,56);

      
    return self;
  }
#endif
  ;

void *Blowfish_Init(void *key,int key_len) 
#ifdef _YO_BLOWFISH_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID, Blowfish_Destruct},
        {Oj_Encrypt8_OjMID, Blowfish_Encrypt8},
        {Oj_Decrypt8_OjMID, Blowfish_Decrypt8},
        {0}};
    
    YO_BLOWFISH *self = Yo_Object(sizeof(YO_BLOWFISH),funcs);

    return Blowfish_Init_Static(self,key,key_len);
  }
#endif
  ;

void *Blowfish_Object_Init_With_Text_Key(char *Skey)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    byte_t key[16] = {0};
    Md5_Digest(Skey,strlen(Skey),key);
    return Blowfish_Init(key,16);
  }
#endif
  ;

#define Blowfish_Decipher(Skey) Blowfish_Object_Init_With_Text_Key(Skey)
#define Blowfish_Encipher(Skey) Blowfish_Object_Init_With_Text_Key(Skey)

void Blowfish_Encrypt(char *data, int len, char *passwd)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    int i;
    YO_BLOWFISH bfctx = {{0},{{0},{0}}};
    Blowfish_Init_Static(&bfctx,passwd,strlen(passwd));
    
    for ( i = 0; i < len && len-i >= 8 ; i += 8 )
      {
        Blowfish_Encrypt8(&bfctx,data+i);
      }
  }
#endif
  ;

void Blowfish_Decrypt(char *data, int len, char *passwd)
#ifdef _YO_BLOWFISH_BUILTIN
  {
    int i;
    YO_BLOWFISH bfctx = {{0},{{0},{0}}};
    Blowfish_Init_Static(&bfctx,passwd,strlen(passwd));
    
    for ( i = 0; i < len && len-i >= 8 ; i += 8 )
      {
        Blowfish_Decrypt8(&bfctx,data+i);
      }
  }
#endif
  ;

#endif /* C_once_A87E119A_8C55_442C_94CE_F1B2DF0121AD */

*/

#ifndef C_once_29A1C0D6_2792_4035_8D0E_9DB1797A4120
#define C_once_29A1C0D6_2792_4035_8D0E_9DB1797A4120

#ifdef _LIBYOYO
#define _YO_BUFFER_BUILTIN
#endif

#include "yoyo.hc"

/* string.hc */
char *Str_Hex_Byte(byte_t val,char pfx,void *out);

typedef struct _YO_BUFFER
  { 
    byte_t *at; 
    int count;
    int capacity;
  } YO_BUFFER;

void Buffer_Clear(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    free(bf->at);
    bf->at = 0;
    bf->count = 0;
    bf->capacity = 0;
  }
#endif
  ;
  
void *Buffer_Init(int count);
YO_BUFFER *Buffer_Reserve(YO_BUFFER *bf,int capacity)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( capacity < 0 )
      __Raise(YO_ERROR_OUT_OF_RANGE,0);

    if ( !bf ) bf = Buffer_Init(0);

    if ( bf->capacity < capacity )
      {
        bf->at = __Realloc_Npl(bf->at,capacity+1);
        bf->capacity = capacity;
      }
      
    return bf;
  }
#endif
  ;

YO_BUFFER *Buffer_Grow_Reserve(YO_BUFFER *bf,int capacity)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( capacity < 0 )
      __Raise(YO_ERROR_OUT_OF_RANGE,0);

    if ( !bf ) bf = Buffer_Init(0);

    if ( bf->capacity < capacity )
      {
        capacity = Min_Pow2(capacity);
        bf->at = __Realloc_Npl(bf->at,capacity+1);
        bf->capacity = capacity;
      }
      
    return bf;
  }
#endif
  ;

void Buffer_Resize(YO_BUFFER *bf,int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    Buffer_Reserve(bf,count);
    bf->count = count;
    if ( bf->at ) bf->at[bf->count] = 0;
  }
#endif
  ;

void Buffer_Grow(YO_BUFFER *bf,int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    Buffer_Grow_Reserve(bf,count);
    bf->count = count;
    bf->at[bf->count] = 0;
  }
#endif
  ;
void Buffer_Append(YO_BUFFER *bf,void *S,int len)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( len < 0 ) /* appending C string */
      len = S?strlen(S):0;

    if ( len && S )
      {
        Buffer_Grow_Reserve(bf,bf->count+len);
        memcpy(bf->at+bf->count,S,len);
        bf->count += len;
        bf->at[bf->count] = 0;
      }
  }
#endif
  ;

void Buffer_Fill_Append(YO_BUFFER *bf,int c,int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    STRICT_REQUIRE( count >= 0 );

    if ( count > 0 )
      {
        Buffer_Grow_Reserve(bf,bf->count+count);
        memset(bf->at+bf->count,c,count);
        bf->count += count;
        bf->at[bf->count] = 0;
      }
  }
#endif
  ;

void Buffer_Print(YO_BUFFER *bf, char *S)
#ifdef _YO_BUFFER_BUILTIN
  {
    Buffer_Append(bf,S,-1);
  }
#endif
  ;

void Buffer_Puts(YO_BUFFER *bf, char *S)
#ifdef _YO_BUFFER_BUILTIN
  {
    Buffer_Append(bf,S,-1);
    Buffer_Fill_Append(bf,'\n',1);
  }
#endif
  ;
  
void Buffer_Set(YO_BUFFER *bf, char *S, int L)
#ifdef _YO_BUFFER_BUILTIN
  {
    Buffer_Resize(bf,0);    
    Buffer_Append(bf,S,L);
  }
#endif
  ;

void Buffer_Printf_Va(YO_BUFFER *bf, char *fmt, va_list va)
#ifdef _YO_BUFFER_BUILTIN
  {
    int q, rq_len;
    
    rq_len = Yo_Detect_Required_Buffer_Size(fmt,va)+1;
    Buffer_Grow_Reserve(bf,bf->count+rq_len);
    
  #ifdef __windoze

    STRICT_REQUIRE(bf->count >= 0 && bf->count <= bf->capacity);
  
    bf->at[bf->count] = 0;
  }
#endif
  ;

void Buffer_Printf(YO_BUFFER *bf, char *fmt, ...)
#ifdef _YO_BUFFER_BUILTIN
  {
    va_list va;
    va_start(va,fmt);
    Buffer_Printf_Va(bf,fmt,va);
    va_end(va);
  }
#endif
  ;

void Buffer_Hex_Append(YO_BUFFER *bf, void *S, int len)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( len < 0 ) /* appending C string */
      len = S?strlen(S):0;

    if ( len && S )
      {
        int i;
        Buffer_Grow_Reserve(bf,bf->count+len*2);
        for ( i = 0; i < len; ++i )
          Str_Hex_Byte( ((byte_t*)S)[i], 0, bf->at+bf->count+i*2 );

        bf->count += len*2;
        bf->at[bf->count] = 0;
      }
  }
#endif
  ;

void Buffer_Quote_Append(YO_BUFFER *bf, void *S, int len, int brk)
#ifdef _YO_BUFFER_BUILTIN
  {
    byte_t *q = S;
    byte_t *p = q;
    byte_t *E;
    
    if ( len < 0 ) 
      len = S?strlen(S):0;

          
        q = p;
      }
  }
#endif
  ;

void Buffer_Html_Quote_Append(YO_BUFFER *bf, void *S, int len)
#ifdef _YO_BUFFER_BUILTIN
  {
    byte_t *q = S;
    byte_t *p = q;
    byte_t *E;
    
    if ( len < 0 ) 
      len = S?strlen(S):0;

          
        q = p;
      }
  }
#endif
  ;

void Buffer_Insert(YO_BUFFER *bf,int pos,void *S,int len)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( len < 0 ) /* appending C string */
      len = S?strlen(S):0;

    if ( pos < 0 ) pos = bf->count + pos + 1;
    if ( pos < 0 || pos > bf->count ) 
      __Raise(YO_ERROR_OUT_OF_RANGE,0);
    
    Buffer_Grow_Reserve(bf,bf->count+len);
    if ( pos < bf->count )
      memmove(bf->at+pos+len,bf->at+pos,bf->count-pos);
    memcpy(bf->at+pos,S,len);
    bf->count += len;
    bf->at[bf->count] = 0;
  }
#endif
  ;


#define Buffer_Take_Data(Bf) __Pool(Buffer_Take_Data_Npl(Bf))
void *Buffer_Take_Data_Npl(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    void *R = bf->at;
    bf->count = 0;
    bf->at = 0;
    bf->capacity = 0;
    return R;
  }
#endif
  ;
  
void *Buffer_Take_Data_Non(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    void *n = Buffer_Take_Data(bf);
    if ( !n ) 
      { 
        n = Yo_Malloc(1);
        *((char*)n) = 0;
      }
    return n;
  }
#endif
  ;
  
#define Buffer_COUNT(Bf)    ((int)((YO_BUFFER *)(Bf))->count)
#define Buffer_CAPACITY(Bf) ((int)((YO_BUFFER *)(Bf))->capacity)
#define Buffer_BEGIN(Bf)    (((YO_BUFFER *)(Bf))->at)
#define Buffer_END(Bf)      (Buffer_BEGIN(Bf)+Buffer_COUNT(Bf))

int Buffer_Count(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( bf )
      return Buffer_COUNT(bf);
    return 0;
  }
#endif
  ;
  
int Buffer_Capacity(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( bf )
      return Buffer_CAPACITY(bf);
    return 0;
  }
#endif
  ;
 void *Buffer_Begin(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( bf )
      return Buffer_BEGIN(bf);
    return 0;
  }
#endif
  ;

void *Buffer_End(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( bf )
      return Buffer_END(bf);
    return 0;
  }
#endif
  ;

void Buffer_Destruct(YO_BUFFER *bf)
#ifdef _YO_BUFFER_BUILTIN
  {
    if ( bf->at )
      free(bf->at);
    __Destruct(bf);
  }
#endif
  ;

void *Buffer_Init(int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    YO_BUFFER *bf = Yo_Object_Dtor(sizeof(YO_BUFFER),Buffer_Destruct);
    if ( count )
      Buffer_Resize(bf,count);
    return bf;
  }
#endif
  ;
  
void *Buffer_Acquire(char *S)
#ifdef _YO_BUFFER_BUILTIN
  {
    YO_BUFFER *bf = Yo_Object_Dtor(sizeof(YO_BUFFER),Buffer_Destruct);
    int L = strlen(S);
    bf->at = S;
    bf->count = L;
    bf->capacity = L;
    return bf;
  }
#endif
  ;

void *Buffer_Zero(int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    YO_BUFFER *bf = Buffer_Init(count);
    if ( bf->count ) 
      memset(bf->at,0,bf->count);
    return bf;
  }
#endif
  ;

void *Buffer_Copy(void *S, int count)
#ifdef _YO_BUFFER_BUILTIN
  {
    YO_BUFFER *bf = Buffer_Init(count);
    if ( count )
      memcpy(bf->at,S,count);
    return bf;
  }
#endif
  ;

#endif /* C_once_29A1C0D6_2792_4035_8D0E_9DB1797A4120 */

Except as contained in this notice, the name of a copyright holder shall not
be used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization of the copyright holder.

*/

#ifndef C_once_C02CA609_3FE5_45AB_B64B_15A73FD72214
#define C_once_C02CA609_3FE5_45AB_B64B_15A73FD72214

#include "yoyo.hc"
#include "string.hc"
#include "buffer.hc"
#include "stdf.hc" 
#include "mime.hc"
#include "xdata.hc"
#include "xdef.hc"
#include "logout.hc"

#ifdef _LIBYOYO
#define _YO_CGI_BUILTIN
#endif

extern char **environ;

enum 
  {
    YO_CGI_BAD_METHOD     = 0,
    YO_CGI_GET            = 1,
    YO_CGI_POST           = 2,
    YO_CGI_HTTP_X_X       = 300000,
    YO_CGI_HTTP_1_0       = 300100,
    YO_CGI_HTTP_1_1       = 300101,
    YO_CGI_CGI_GW         = 100000,
    YO_CGI_CGI_X_X        = 100000,
    YO_CGI_CGI_1_0        = 100100,
    YO_CGI_CGI_1_1        = 100101,
    YO_CGI_FAST_CGI_GW    = 200000,
    YO_CGI_FAST_CGI_X_X   = 200000,
    YO_CGI_FAST_CGI_1_0   = 200100,
    YO_CGI_FAST_CGI_1_1   = 200101,
    YO_CGI_NO_CONTENT     = 0,
    YO_CGI_URLENCODED     = 1,
    YO_CGI_OCTETSTREAM    = 2,
    YO_CGI_MULTIPART      = 3,
    YO_CGI_POST_MAX_PAYLOAD = 64*KILOBYTE,
    YO_CGI_OUT_TEXTHTML = 200,
    YO_CGI_OUT_REDIRECT = 301,
    YO_CGI_OUT_DATASTREAM = 299,
    YO_CGI_OUT_NOTFOUND = 404,
  };

/* YO_CGI_COOKIE does not require specific destructor, use free */
typedef struct _YO_CGI_COOKIE
  {
    struct _YO_CGI_COOKIE *next;
    char *value;
    time_t expire;
    int  secure;
    char name[1];
  } YO_CGI_COOKIE;

typedef struct _YO_CGI_UPLOAD
  {
    struct _YO_CGI_UPLOAD *next;
    char *path;
    char *mimetype;
    char *original;
    int length;
    int status;
    char name[1];
  } YO_CGI_UPLOAD;

typedef struct _YO_CGI
  {
    YO_XNODE *params;
    char *server_software;
    char *server_name;
    char *request_uri;
    char *remote_addr;
    char *referer;
    char *query_string;
    char *path_info;
    char *content_boundary; /* can be null */
    char **langlist;
    int gateway_interface;
    int server_protocol;
    int server_port;
    int request_method;
    int content_length;
    int content_type;
    YO_CGI_COOKIE *cookie_in;
    YO_CGI_COOKIE *cookie_out;
    YO_CGI_UPLOAD *upload;
    YO_BUFFER *out;
    void *dstrm;
    char *dstrm_mimetype;
  } YO_CGI;

#define Cgi_Langlist(Cgir) ((Cgir)->langlist)

void Cgi_Destruct(YO_CGI *self)
#ifdef _YO_CGI_BUILTIN
  {
    __Gogo
      {
        YO_CGI_COOKIE *qoo;
        for ( qoo = self->cookie_in; qoo; ) { void *q = qoo->next; free(qoo); qoo = q; }
        for ( qoo = self->cookie_out; qoo; ) { void *q = qoo->next; free(qoo); qoo = q; }
      }
    
    __Gogo
      {
        YO_CGI_UPLOAD *qoo, *qoo1;
        for ( qoo = self->upload; qoo; )
          {
            qoo1 = qoo->next;
            if ( qoo->path && File_Exists(qoo->path) ) 
              __Try_Except
                File_Unlink(qoo->path,0);
              __Except
                Log_Error("when unlink uploaded file `%s`, occured: %s",
                                         qoo->path, __Format_Error());
            free(qoo);
            qoo = qoo1;
          }
      }
    
    if (self->langlist) 
      {
        char **qoo;
        for ( qoo = self->langlist; *qoo; ++qoo )
          free(*qoo);
        free(self->langlist);
      }
    
    free(self->server_software);
    free(self->server_name);
    free(self->request_uri);
    free(self->remote_addr);
    free(self->referer);
    free(self->query_string);
    free(self->path_info);
    free(self->content_boundary);
    free(self->dstrm_mimetype);
    __Unrefe(self->params);
    __Unrefe(self->out);
    __Unrefe(self->dstrm);
    memset(self,0xfe,sizeof(*self)); /* !!! */
    __Destruct(self);
  }
#endif
  ;
  
YO_CGI_COOKIE **Cgi_Find_Cookie_(YO_CGI_COOKIE **qoo,char *name, int name_len)
#ifdef _YO_CGI_BUILTIN
  {
    while ( *qoo )
      {
        int i;
        char *Q = (*qoo)->name;
        char *N = name;
        for ( i = 0; i < name_len; ++i )
          if ( Q[i] != N[i] )
            break;
        if ( i == name_len && !Q[i] )
          break;
        qoo = &(*qoo)->next;
      }
    return qoo;
  }
#endif
  ;

#define Cgi_Set_Cookie(Cgir,Name,Value,Expire) Cgi_Set_Cookie_(&(Cgir)->cookie_out,(Name),-1,(Value),-1,0,(Expire));
#define Cgi_Set_Secure_Cookie(Cgir,Name,Value,Expire) Cgi_Set_Cookie_(&(Cgir)->cookie_out,(Name),-1,(Value),-1,1,(Expire));
void Cgi_Set_Cookie_(YO_CGI_COOKIE **qoo, char *name, int name_len, char *value, int value_len, int secure, time_t expire)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_COOKIE **cookie;
    
    if ( name_len < 0 ) name_len = name?strlen(name):0;
    if ( value_len < 0 ) value_len = value?strlen(value):0;
    
    cookie = Cgi_Find_Cookie_(qoo,name,name_len);
    if ( *cookie )
      {
        free(*cookie);
        *cookie = 0;
      }
      
    *cookie = __Malloc_Npl(sizeof(YO_CGI_COOKIE)+(name_len+value_len+1));
    (*cookie)->value = (*cookie)->name+name_len+1;
    memcpy((*cookie)->name,name,name_len);
    (*cookie)->name[name_len] = 0;
    memcpy((*cookie)->value,value,value_len);
    (*cookie)->value[value_len] = 0;
    (*cookie)->secure = secure;
    (*cookie)->expire = expire;
    (*cookie)->next = 0;
  }
#endif
  ;
  
char *Cgi_Get_Cookie(YO_CGI *cgir,char *name)
#ifdef _YO_CGI_BUILTIN
  {
    if ( name )
      {
        YO_CGI_COOKIE **q = Cgi_Find_Cookie_(&cgir->cookie_in,name,strlen(name));
        if ( *q )
          return (*q)->value;
      }
    return 0;
  }
#endif
  ;

YO_CGI_UPLOAD *Cgi_Find_Upload(YO_CGI *cgir, char *upload_name)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_UPLOAD *up = cgir->upload;
    for ( ; up ; up = up->next )
      if ( Str_Equal_Nocase(up->name,upload_name) )
        break;
    return up;
  }
#endif
  ;

char *Cgi_Mime_Of_Upload(YO_CGI *cgir, char *upload_name)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_UPLOAD *up = Cgi_Find_Upload(cgir,upload_name);
    if ( up )
      return up->mimetype;
    return 0;
  }
#endif
  ;

char *Cgi_Get_Upload_Path(YO_CGI *cgir, char *upload_name)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_UPLOAD *up = Cgi_Find_Upload(cgir,upload_name);
    if ( up )
      return up->path;
    else
      __Raise_Format(YO_ERROR_INVALID_PARAM,
        ("CGI request does not have upload with name '%s'",upload_name));
    return 0;
  }
#endif
  ;

void *Cgi_Open_Upload(YO_CGI *cgir, char *upload_name)
#ifdef _YO_CGI_BUILTIN
  {
    return Cfile_Open(Cgi_Get_Upload_Path(cgir,upload_name),"r");
  }
#endif
  ;

YO_CGI_UPLOAD *Cgi_Attach_Upload(YO_CGI_UPLOAD **upload, char *path, char *mimetype, char *name, char *original, int len)
#ifdef _YO_CGI_BUILTIN
  {
    int path_len = path?strlen(path):0;
    int mime_len = mimetype?strlen(mimetype):0;
    int name_len = name?strlen(name):0;
    int orig_len = original?strlen(original):0;
    int mem_len = path_len+1+mime_len+1+orig_len+1+name_len+sizeof(YO_CGI_UPLOAD);
    YO_CGI_UPLOAD *u = __Malloc_Npl(mem_len);
    memset(u,0,mem_len);
    u->path = u->name+name_len+1;
    u->mimetype = u->path+path_len+1;
    u->original = u->mimetype+mime_len+1;
    if ( name_len ) memcpy(u->name,name,name_len);
    if ( path_len ) memcpy(u->path,path,path_len);
    if ( mime_len ) memcpy(u->mimetype,mimetype,mime_len);
    if ( orig_len ) memcpy(u->original,original,orig_len);
    u->length = len;
    
    while ( *upload ) upload = &(*upload)->next;
    *upload = u;
    return u;
  }
#endif
  ;

int Cgi_Recognize_Request_Method(char *method)
#ifdef _YO_CGI_BUILTIN
  {
    if ( method )
      {
        if ( !strcmp_I(method,"get") )
          return YO_CGI_GET;
        if ( !strcmp_I(method,"post") )
          return YO_CGI_POST;
      }
    return 0;
  } 
#endif
  ;
  
int Cgi_Recognize_Content_Type(char *cont_type)
#ifdef _YO_CGI_BUILTIN
  {
    if ( cont_type )
      {
        while ( Isspace(*cont_type) ) ++cont_type;
        if ( !strncmp_I(cont_type,"multipart/form-data;",20) )
          return YO_CGI_MULTIPART;
        if ( !strcmp_I(cont_type,"application/x-www-form-urlencoded") )
          return YO_CGI_URLENCODED;
        if ( !strcmp_I(cont_type,"application/octet-stream") )
          return YO_CGI_OCTETSTREAM;
      }
    return 0;
  }
#endif
  ;
  
int Cgi_Recognize_Gateway_Ifs(char *gwifs)
#ifdef _YO_CGI_BUILTIN
  {
    if ( gwifs )
      {
        while ( Isspace(*gwifs) ) ++gwifs;
        if ( !strncmp_I(gwifs,"cgi/1.1",9) )
          return YO_CGI_CGI_1_1;
        if ( !strncmp_I(gwifs,"cgi/1.0",9) )
          return YO_CGI_CGI_1_0;
      }
    return YO_CGI_CGI_X_X;
  }
#endif
  ;
  
int Cgi_Recognize_Protocol(char *proto)
#ifdef _YO_CGI_BUILTIN
  {
    if ( proto )
      {
        while ( Isspace(*proto) ) ++proto;
        if ( !strncmp_I(proto,"http/1.1",10) )
          return YO_CGI_HTTP_1_1;
        if ( !strncmp_I(proto,"http/1.0",10) )
          return YO_CGI_HTTP_1_0;
      }
    return 0;
  }
#endif
  ;
  
YO_CGI *Cgi_Init()
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI *self = __Object_Dtor(sizeof(YO_CGI),Cgi_Destruct);

    setlocale(LC_NUMERIC,"C");
    setlocale(LC_TIME,"C");

    self->server_software = Str_Copy_Npl(getenv("SERVER_SOFTWARE"),-1);
    self->gateway_interface = Cgi_Recognize_Gateway_Ifs(getenv("GATEWAY_INTERFACE"));
    self->server_protocol = Cgi_Recognize_Protocol(getenv("SERVER_PROTOCOL"));

    self->server_name = Str_Copy_Npl(getenv("SERVER_NAME"),-1);
    self->server_port = Str_To_Int_Dflt(getenv("SERVER_PORT"),80);

    self->request_uri = Str_Copy_Npl(getenv("REQUEST_URI"),-1);
    self->remote_addr = Str_Copy_Npl(getenv("REMOTE_ADDR"),-1);
    self->referer = Str_Copy_Npl(getenv("HTTP_REFERER"),-1);

    self->request_method = Cgi_Recognize_Request_Method(getenv("REQUEST_METHOD"));
    self->query_string = Str_Copy_Npl(getenv("QUERY_STRING"),-1);
    self->path_info = Str_Copy_Npl(getenv("PATH_INFO"),-1);    
    self->content_length = Str_To_Int_Dflt(getenv("CONTENT_LENGTH"),0);
    
    __Gogo
      {
        char *S = getenv("CONTENT_TYPE");
        self->content_type = Cgi_Recognize_Content_Type(S);
        if ( self->content_type == YO_CGI_MULTIPART )
          {
            char *bndr = strchr(S,';');
            if ( bndr )
              {
                ++bndr;
                while ( Isspace(*bndr) ) ++bndr;
                if ( Str_Starts_With(bndr,"boundary=") )
                  self->content_boundary = Str_Concat_Npl("--",bndr+9);
              }
          }
      }
     
     __Gogo
      {
        char *S = getenv("HTTP_COOKIE");
        if ( S ) while (*S)
          {
            int nam_len,val_len;
            char *nam;
            char *val;
            while ( Isspace(*S) ) ++S;
            nam = S;
            while ( *S && *S != '=' && *S != ';' ) ++S;
            if ( *S == '=' )
              {
                nam_len = S - nam;
                ++S;
                val = S;
                while ( *S && *S != ';' ) ++S;
              }
            else
              {
                val = nam;
                nam_len = 0;
              }
            val_len = S-val;
            if ( *S == ';' ) ++S;
            Cgi_Set_Cookie_(&self->cookie_in,nam,nam_len,val,val_len,0,0);
          }
      }
      
    __Gogo
      {
        YO_ARRAY *arr = 0;
        char *S1, *S2, *S = getenv("HTTP_ACCEPT_LANGUAGE");
        if ( S )
          {
            arr = Array_Pchars();
            while ( *S )
              {
                S1 = S;
                S2 = S;
                while ( *S && *S != ',' ) ++S;
                while ( S2 < S && *S2 != ';' ) ++S2;
                Array_Push(arr,Str_Copy_Npl(S1,S2-S1));
                while ( *S == ',' ) ++S;
              }
            Array_Push(arr,0);
            self->langlist = Array_Take_Data_Npl(arr);
          }
      }
    
    self->out = __Refe(Buffer_Init(0));
    return self;
  }
#endif
  ;
  
void Cgi_Format_Bf(YO_CGI *self, YO_BUFFER *bf)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_COOKIE *q;
    YO_CGI_UPLOAD *u;
    
    Buffer_Printf(bf,"YO_CGI(%08x){\n",self);
    Buffer_Printf(bf,"  server_software = '%s'\n",self->server_software);
    Buffer_Printf(bf,"  server_name = '%s'\n",self->server_name);
    Buffer_Printf(bf,"  request_uri = '%s'\n",self->request_uri);
    Buffer_Printf(bf,"  remote_addr = '%s'\n",self->remote_addr);
    Buffer_Printf(bf,"  referer = '%s'\n",self->referer);
    Buffer_Printf(bf,"  query_string = '%s'\n",self->query_string);
    Buffer_Printf(bf,"  path_info = '%s'\n",self->path_info);
    Buffer_Printf(bf,"  content_boundary = '%s'\n",self->content_boundary?self->content_boundary:"");
    Buffer_Printf(bf,"  gateway_interface = %d\n",self->gateway_interface);
    Buffer_Printf(bf,"  server_protocol = %d\n",self->server_protocol);
    Buffer_Printf(bf,"  server_port = %d\n",self->server_port);
    Buffer_Printf(bf,"  request_method = %d\n",self->request_method);
    Buffer_Printf(bf,"  content_length = %d\n",self->content_length);
    Buffer_Printf(bf,"  content_type = %d\n",self->content_type);
    Buffer_Append(bf,"  params:\n",-1);
    if (self->params) Def_Format_Into(bf,self->params,2);
    Buffer_Append(bf,"  cookie-in:\n",-1);
    for ( q = self->cookie_in; q; q = q->next ) 
      Buffer_Printf(bf,"    %s => %s\n",q->name,q->value);
    Buffer_Append(bf,"  cookie-out:\n",-1);
    for ( q = self->cookie_out; q; q = q->next ) 
      Buffer_Printf(bf,"    %s => %s  ((%sexpire:%ld))\n",q->name,q->value,q->secure?"SECURED ":"",q->expire);
    Buffer_Append(bf,"  upload:\n",-1);
    for ( u = self->upload; u; u = u->next )
      Buffer_Printf(bf,"    %s => %s (%d bytes) %s `%s`\n",u->name,u->path,u->length,u->mimetype,u->original);
    Buffer_Printf(bf,"}\n");
  }
#endif
  ;
  
char *Cgi_Format_Str(YO_CGI *self)
#ifdef _YO_CGI_BUILTIN
  {
    YO_BUFFER *bf = Buffer_Init(0);
    Cgi_Format_Bf(self,bf);
    return Buffer_Take_Data(bf);
  }
#endif
  ;

char *Cgi_Format_Cookies_Out(YO_CGI *self)
#ifdef _YO_CGI_BUILTIN
  {
    YO_CGI_COOKIE *q;
    YO_BUFFER bf = {0};
    for ( q = self->cookie_out; q; q = q->next ) 
      {
        Buffer_Append(&bf,"Set-Cookie: ",-1);
        Buffer_Append(&bf,q->name,-1);
        Buffer_Fill_Append(&bf,'=',1);
        Buffer_Append(&bf,q->value,-1);
        if ( q->expire )
          {
            //time_t gmt_time;
            static char *wday [] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
            static char *mon  [] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", 
                                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
            struct tm *tm = gmtime(&q->expire);
            Buffer_Printf(&bf,"; expires=%s, %02d-%s-%04d %02d:%02d:%02d GMT",
              wday[tm->tm_wday%7],
              tm->tm_mday,
              mon[tm->tm_mon%12],
              tm->tm_year+1900,
              tm->tm_hour,tm->tm_min,tm->tm_sec);
          }
        if ( q->secure )
          Buffer_Append(&bf,"; secure",-1);

        Buffer_Append(&bf,"; HttpOnly",-1);
        if ( q->next )
          Buffer_Fill_Append(&bf,'\n',1);
      }
    if ( bf.at )
      return Buffer_Take_Data(&bf);
    else
      return "";
  }
#endif
  ;

char *Cgi_Upload_Part(
  YO_CGI *cgir, longptr_t out, Unknown_Write_Proc xwrite, 
  char *S, char *bf, int *L, int maxlen)
#ifdef _YO_CGI_BUILTIN
  {
    int count = 0;
    int cb_l = strlen(cgir->content_boundary);
    
    while (S && *L)
      {
        int j = 0, k = 0;
        if ( strncmp(S,cgir->content_boundary,cb_l) == 0 )
          break;
        
        //++j;
        
        while ( *L-j >= cb_l+2 )
          {
            k = 0;
            if ( S[j] == '\r' ) ++k;
            if ( S[j+k] == '\n' ) ++k;
            if ( 0 == strncmp(S+j+k,cgir->content_boundary,cb_l) )
              break;
            ++j;
          }
        
        if ( count + j > maxlen )
          __Raise(YO_ERROR_TO_BIG,__yoTa("payload size out of limit",0));
        Unknown_Write(out,S,j,xwrite);
        count += j;
        S = Stdin_Pump_Part(bf,S+j+k,L);
        if ( *L < cb_l ) 
          __Raise(YO_ERROR_IO,__yoTa("uncomplete request",0));
      }

    return S;
  }
#endif
  ;
  
char *Cgi_Strip(char *S)
#ifdef _YO_CGI_BUILTIN
  {
    if ( S && *S == '"' )
      {
        int L = strlen(S);
        if ( S[L-1] == '"' ) S[L-1] = 0;
        return S+1;
      }
    return S;
  }
#endif
  ;
  
char *Cgi_Multipart_Next(
  YO_CGI *cgir, char *upload_dir, int upload_maxsize, char *bf,char *S, int *L)
#ifdef _YO_CGI_BUILTIN
  {
    char *SE;
    char *name, *filename, *ctype;
    int cb_l = strlen(cgir->content_boundary);
     
    while ( *S && Isspace(*S) ) ++S;
    
    if ( 0 == strncmp(S,cgir->content_boundary,cb_l) )
      {
        S = Stdin_Pump_Part(bf,S,L);
        SE = S+1;
        while ( *SE )
          {
            if ( *SE == '\n' && SE[1] == '\n' ) 
              { SE += 2; break; }
            if ( *SE == '\n' && SE[1] == '\r' && SE[2] == '\n') 
              { SE += 3; break; }
            ++SE;
          }
        if ( *SE )
          {
            SE[-1] = 0;
            name = Cgi_Strip(Str_Fetch_Substr(S,"name=",0,";\n\r"));
            filename = Cgi_Strip(Str_Fetch_Substr(S,"filename=",0,";\n\r"));
            ctype = Cgi_Strip(Str_Fetch_Substr(S,"Content-Type:"," ",";\n\r"));
            S = Stdin_Pump_Part(bf,SE,L);
            if ( ctype || filename )
              {
                char *tmpfname = Path_Unique_Name(upload_dir,"cgi-",".upl");
                YO_CFILE *f = Cfile_Open(tmpfname,"w+P");
                YO_CGI_UPLOAD *u = Cgi_Attach_Upload(&cgir->upload,tmpfname,ctype,name,filename,0);
                S = Cgi_Upload_Part(cgir,(longptr_t)f,&Cf_Write,S,bf,L,upload_maxsize);
                Cfile_Flush(f);
                u->length = Cfile_Length(f);
                Cfile_Close(f);
              }
            else
              {
                YO_BUFFER *val = Buffer_Init(0);
                S = Cgi_Upload_Part(cgir,(longptr_t)val,&Bf_Write,S,bf,L,YO_CGI_POST_MAX_PAYLOAD);
                Xvalue_Set_Str(Xnode_Deep_Value(cgir->params,name),val->at,val->count);
              }
            return S;
          }
      }
    return 0;
  }
#endif
  ;
  
void Cgi_Process_Multipart_Content(YO_CGI *cgir, char *upload_dir, int upload_maxsize)
#ifdef _YO_CGI_BUILTIN
  {
    char bf[YO_STDF_PUMP_BUFFER];
    int L = Stdin_Pump(bf);
    char *S = bf;
    while ( S && L )
      __Auto_Release
        S = Cgi_Multipart_Next(cgir,upload_dir,upload_maxsize,bf,S,&L);
  }
#endif
  ;
  
YO_XNODE *Cgi_Query_Params(YO_CGI *cgir, char *upload_dir, int upload_maxsize)
#ifdef _YO_CGI_BUILTIN
  {
    if ( !cgir->params ) __Auto_Release
      {
        char lbuf[1024], c;
        char *q, *key, *value, *qE = lbuf+(sizeof(lbuf)-1);
        char *S = 0;
        cgir->params = __Refe(Xdata_Init());
        if ( !upload_dir ) upload_dir = Temp_Directory();
        if ( cgir->request_method == YO_CGI_GET )
          {
            S = cgir->query_string;
          }
        else if ( cgir->request_method == YO_CGI_POST )
          {
            if ( cgir->content_type == YO_CGI_MULTIPART )
              {
                if ( cgir->content_boundary )
                  Cgi_Process_Multipart_Content(cgir,upload_dir,upload_maxsize);
              }
            else if ( cgir->content_length < YO_CGI_POST_MAX_PAYLOAD )
              {
                int count = cgir->content_length;
                int l = 0;
                S = __Malloc(count+1);
                while ( l < count )
                  {
                    int q = fread(S+l,1,count-l,stdin);
                    if ( q < 0 )
                      __Raise_Format(YO_ERROR_IO,
                        (__yoTa("failed to read request content: %s",0),strerror(ferror(stdin))));
                    l += q;
                  }
                S[count] = 0;
              }
            else
              __Raise(YO_ERROR_TO_BIG,__yoTa("payload size out of limit",0));
          }
        if ( S && (cgir->request_method == YO_CGI_GET || cgir->content_type == YO_CGI_URLENCODED) )
          {
            while ( *S )
              {
                value = 0;
                key = q = lbuf;
                while ( *S && *S == '&' ) ++S;
                while ( *S && *S != '=' && *S != '&' )
                  {
                    c = ( *S != '%' && *S != '+' ) ? *S++ : Str_Urldecode_Char(&S);
                    if ( q >= lbuf && q < qE ) *q++ = c;
                  }
                if ( q >= lbuf && q < qE ) *q++ = 0;
                value = q; *q = 0; /* if (q == qE) there is one more char for final zero */
                if ( *S == '=' ) 
                  {
                    ++S;
                    while ( *S && *S != '&' )
                      {
                        c = ( *S != '%' && *S != '+' ) ? *S++ : Str_Urldecode_Char(&S);
                        if ( q >= lbuf && q < qE ) *q++ = c;
                      }
                  }
                *q = 0; /* if (q == qE) there is one more char for final zero */
                Xvalue_Set_Str(Xnode_Deep_Value(cgir->params,key),value,q-value);
              }
          }
      }
    return cgir->params;
  }
#endif
  ;
  
#define Cgi_Get_Outbuf(Cgir) ((Cgir)->out)
#define Cgi_Get_Len(Cgir) ((Cgir)->out->count)
#define Cgi_Get_Cstr(Cgir) ((Cgir)->out->at)
#define Cgi_Puts(Cgir,S) Buffer_Puts(Cgir->out,S)
#define Cgi_Fill(Cgir,C,N) Buffer_Fill_Append(Cgir->out,C,N)
#define Cgi_Append(Cgir,S,L) Buffer_Append(Cgir->out,S,L)

void Cgi_Printf(YO_CGI *cgir, char *fmt, ...)
#ifdef _YO_CGI_BUILTIN
  {
    va_list va;
    va_start(va,fmt);
    Buffer_Printf_Va(cgir->out,fmt,va);
    va_end(va);
  }
#endif
  ;

void Cgi_Write_Out(YO_CGI *cgir, int out_status)
#ifdef _YO_CGI_BUILTIN
  {
    if ( out_status == YO_CGI_OUT_TEXTHTML )
      {
        Stdout_Put("Content-Type: text/html; charset=utf-8\r\n");
        printf("Content-Length: %d\r\n\r\n",Cgi_Get_Len(cgir));
        Stdout_Put(cgir->out->at);
      }
    else if ( out_status == YO_CGI_OUT_REDIRECT )
      {
        Stdout_Put("Location: ");
        Stdout_Put(cgir->out->at);
        Stdout_Put("\r\n");
        Stdout_Put(Cgi_Format_Cookies_Out(cgir));
        Stdout_Put("\r\n\r\n");
      }
    else if ( out_status == YO_CGI_OUT_DATASTREAM )
      {
        char bf[YO_FILE_COPY_BUFFER_SIZE];
        int count = 0;
        void *src = cgir->dstrm;
        int (*xread)(void*,void*,int,int) = Yo_Find_Method_Of(&src,Oj_Read_OjMID,YO_RAISE_ERROR);
        int len = Oj_Available(cgir->dstrm);
        Stdout_Put("Content-Type: ");
        Stdout_Put(cgir->dstrm_mimetype);
        Stdout_Put("\r\n");
        printf("Content-Length: %d\r\n\r\n",len);
        for ( ;; )
          {
            int i = xread(src,bf,YO_FILE_COPY_BUFFER_SIZE,0);
            if ( !i ) break;
            fwrite(bf,1,i,stdout);
            count += i;
          }
      }
    else /* empty page */
      {
        Stdout_Put("Content-Type: text/html; charset=utf-8\n");
        Stdout_Put("Content-Length: 0\n\n");
      }
    fflush(stdout);
  }
#endif
  ;

#endif /* C_once_C02CA609_3FE5_45AB_B64B_15A73FD72214 */

*/

#ifndef C_once_1F19AF84_9BBE_46CC_87A4_8252243D7219
#define C_once_1F19AF84_9BBE_46CC_87A4_8252243D7219

#ifdef _LIBYOYO
#define _YO_CIPHER_BUILTIN
#endif

#include "yoyo.hc"
#include "md5.hc"
#include "sha2.hc"

#ifdef _YO_CIPHER_BUILTIN
# define _YO_CIPHER_BUILTIN_CODE(Code) Code
# define _YO_CIPHER_EXTERN 
#else
# define _YO_CIPHER_BUILTIN_CODE(Code)
# define _YO_CIPHER_EXTERN extern 
#endif

_YO_CIPHER_EXTERN char Oj_Encrypt8_OjMID[] _YO_CIPHER_BUILTIN_CODE ( = "encrypt8/@*" );
_YO_CIPHER_EXTERN char Oj_Decrypt8_OjMID[] _YO_CIPHER_BUILTIN_CODE ( = "decrypt8/@*" );
_YO_CIPHER_EXTERN char Oj_Encrypt16_OjMID[] _YO_CIPHER_BUILTIN_CODE ( = "encrypt16/@*" );
_YO_CIPHER_EXTERN char Oj_Decrypt16_OjMID[] _YO_CIPHER_BUILTIN_CODE ( = "decrypt16/@*" );

void Oj_Encrypt8(void *cipher,void *block8) _YO_CIPHER_BUILTIN_CODE(
  { ((void(*)(void*,void*))Yo_Find_Method_Of(cipher,Oj_Encrypt8_OjMID,YO_RAISE_ERROR))
        (cipher,block8); });

void Oj_Decrypt8(void *cipher,void *block8) _YO_CIPHER_BUILTIN_CODE(
  { ((void(*)(void*,void*))Yo_Find_Method_Of(cipher,Oj_Decrypt8_OjMID,YO_RAISE_ERROR))
        (cipher,block8); });
        
void Oj_Encrypt16(void *cipher,void *block16) _YO_CIPHER_BUILTIN_CODE(
  { ((void(*)(void*,void*))Yo_Find_Method_Of(cipher,Oj_Encrypt16_OjMID,YO_RAISE_ERROR))
        (cipher,block16); });

void Oj_Decrypt16(void *cipher,void *block16) _YO_CIPHER_BUILTIN_CODE(
  { ((void(*)(void*,void*))Yo_Find_Method_Of(cipher,Oj_Decrypt16_OjMID,YO_RAISE_ERROR))
        (cipher,block16); });

void _Oj_Check_Buffer_Size_N_Alignment_8(int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    if ( S_len < 8 ) 
      __Raise(YO_ERROR_NO_ENOUGH,__yoTa("data buffer to small",0));
    
    if ( S_len % 8 )
      __Raise(YO_ERROR_UNALIGNED,__yoTa("size of data buffer should be aligned to 8 bytes",0));
  }
#endif
  ;

void _Oj_Check_Buffer_Size_N_Alignment_16(int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    if ( S_len < 16 ) 
      __Raise(YO_ERROR_NO_ENOUGH,__yoTa("data buffer to small",0));
    
    if ( S_len % 16 )
      __Raise(YO_ERROR_UNALIGNED,__yoTa("size of data buffer should be aligned to 16 bytes",0));
  }
#endif
  ;

void _Oj_Encrypt_Decrypt_ECB_8(void *cipher, void (*f8)(void*,void*), void *S, int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    int i;
    
    _Oj_Check_Buffer_Size_N_Alignment_8(S_len);
    
    for ( i = 0; i < S_len/8; ++i )
      {
        byte_t *p = (byte_t*)S+i*8;
        f8(cipher,p);
      }
  }
#endif
  ;

void _Oj_Encrypt_Decrypt_ECB_16(void *cipher, void (*f16)(void*,void*), void *S, int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    int i;
    
    _Oj_Check_Buffer_Size_N_Alignment_16(S_len);
    
    for ( i = 0; i < S_len/16; ++i )
      {
        byte_t *p = (byte_t*)S+i*16;
        f16(cipher,p);
      }
  }
#endif
  ;

void Oj_Encrypt_ECB(void *cipher, void *S, int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    void (*f)(void*,void*) = Yo_Find_Method_Of(&cipher,Oj_Encrypt8_OjMID,0);
    
    if ( f )
      _Oj_Encrypt_Decrypt_ECB_8(cipher,f,S,S_len);
    else if ( 0 != (f = Yo_Find_Method_Of(&cipher,Oj_Encrypt16_OjMID,0)) )
      _Oj_Encrypt_Decrypt_ECB_16(cipher,f,S,S_len);
    else
      __Raise(YO_ERROR_METHOD_NOT_FOUND,
              __yoTa("cipher does not contain Oj_Encrypt8_OjMID or Oj_Encrypt16_OjMID mothod",0));
  }
#endif
  ;

void Oj_Decrypt_ECB(void *cipher, void *S, int S_len)
#ifdef _YO_CIPHER_BUILTIN
  {
    void (*f)(void*,void*) = Yo_Find_Method_Of(&cipher,Oj_Decrypt8_OjMID,0);
    
    if ( f )
      _Oj_Encrypt_Decrypt_ECB_8(cipher,f,S,S_len);
    else if ( 0 != (f = Yo_Find_Method_Of(&cipher,Oj_Decrypt16_OjMID,0)) )
      _Oj_Encrypt_Decrypt_ECB_16(cipher,f,S,S_len);
    else
      __Raise(YO_ERROR_METHOD_NOT_FOUND,
              __yoTa("cipher does not contain Oj_Decrypt8_OjMID or Oj_Decrypt16_OjMID mothod",0));
  }
#endif
  ;

quad_t _Oj_Encrypt_Decrypt_XEX_8(void *cipher, void (*f8)(void*,void*), void *cipher2, void (*xex)(void*,void*), void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    int i,j, n = xex?8:16;
    byte_t q16[16] = {0};
    
    _Oj_Check_Buffer_Size_N_Alignment_8(S_len);
    
    for ( i = 0; i < S_len/8; ++i )

    
    return st;
  }
#endif
  ;

quad_t _Oj_Encrypt_Decrypt_XEX_16(void *cipher, void (*f16)(void*,void*), void *cipher2, void (*xex)(void*,void*), void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    int i,j, n = xex?16:32;
    byte_t q32[32] = {0};
    
    _Oj_Check_Buffer_Size_N_Alignment_16(S_len);
    
    for ( i = 0; i < S_len/16; ++i )

    
    return st;
  }
#endif
  ;

quad_t Oj_Encrypt_XEX_2(void *cipher, void *cipher2, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    void (*encrypt)(void*,void*) = Yo_Find_Method_Of(&cipher,Oj_Encrypt8_OjMID,0);
    if ( encrypt ) 
      {
        if ( !cipher2 )
          return _Oj_Encrypt_Decrypt_XEX_8(cipher,encrypt,0,0,S,S_len,st);
        else

        else
          {
            void (*encrypt2)(void*,void*) = Yo_Find_Method_Of(&cipher2,Oj_Encrypt16_OjMID,YO_RAISE_ERROR);
            return _Oj_Encrypt_Decrypt_XEX_16(cipher,encrypt,cipher2,encrypt2,S,S_len,st);
          }
      }
    else
      __Raise(YO_ERROR_METHOD_NOT_FOUND,
              __yoTa("cipher does not contain Oj_Encrypt8_OjMID or Oj_Encrypt16_OjMID mothod",0));
    return 0;
  }
#endif
  ;

quad_t Oj_Decrypt_XEX_2(void *cipher, void *cipher2, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    void (*decrypt)(void*,void*) = Yo_Find_Method_Of(&cipher,Oj_Decrypt8_OjMID,0);
    if ( decrypt )
      {
        if ( !cipher2 )
          return _Oj_Encrypt_Decrypt_XEX_8(cipher,decrypt,0,0,S,S_len,st);
        else

        else
          {
            void (*encrypt)(void*,void*) = Yo_Find_Method_Of(&cipher2,Oj_Encrypt16_OjMID,YO_RAISE_ERROR);
            return _Oj_Encrypt_Decrypt_XEX_16(cipher,decrypt,cipher2,encrypt,S,S_len,st);
          }
      }
    else
      __Raise(YO_ERROR_METHOD_NOT_FOUND,
              __yoTa("cipher does not contain Oj_Decrypt8_OjMID or Oj_Decrypt16_OjMID mothod",0));
    return 0;
  }
#endif
  ;

quad_t Oj_Encrypt_XEX(void *cipher, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    return Oj_Encrypt_XEX_2(cipher,cipher,S,S_len,st);
  }
#endif
  ;

quad_t Oj_Decrypt_XEX(void *cipher, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    return Oj_Decrypt_XEX_2(cipher,cipher,S,S_len,st);
  }
#endif
  ;

quad_t Oj_Encrypt_XEX_MDSH(void *cipher, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    return Oj_Decrypt_XEX_2(cipher,0,S,S_len,st);
  }
#endif
  ;

quad_t Oj_Decrypt_XEX_MDSH(void *cipher, void *S, int S_len, quad_t st)
#ifdef _YO_CIPHER_BUILTIN
  {
    return Oj_Decrypt_XEX_2(cipher,0,S,S_len,st);
  }
#endif
  ;

#endif /* C_once_1F19AF84_9BBE_46CC_87A4_8252243D7219 */

*/

#ifndef C_once_A1549AAE_F443_4982_AFD4_F5BE02C14DE6
#define C_once_A1549AAE_F443_4982_AFD4_F5BE02C14DE6

#ifdef _LIBYOYO
#define _YO_CRC_BUILTIN
#endif

#include "yoyo.hc"

#ifdef _YO_CRC_BUILTIN
# define _YO_CRC_BUILTIN_CODE(Code) Code
# define _YO_CRC_EXTERN 
#else
# define _YO_CRC_BUILTIN_CODE(Code)
# define _YO_CRC_EXTERN extern 
#endif

_YO_CRC_EXTERN char Oj_Digest_Update_OjMID[] _YO_CRC_BUILTIN_CODE( = "digest-update/@*i"); 
void Oj_Digest_Update(void *dgst,void *buf,int L) _YO_CRC_BUILTIN_CODE(
  { ((void(*)(void*,void*,int))Yo_Find_Method_Of(&dgst,Oj_Digest_Update_OjMID,YO_RAISE_ERROR))
        (dgst,buf,L); });

uint_t    Crc_32(uint_t crc, void *, int len);
ushort_t  Crc_16(ushort_t crc, void *, int len);
byte_t    Crc_8(byte_t crc, void *, int len);
byte_t    Crc_8_Of_Cstr(char *S);
uint_t    Adler_32(uint_t adler, void *, int len);

#define Digest_Crc_32(Data,Len) Crc_32(0,Data,Len)
#define Digest_Crc_16(Data,Len) Crc_16(0,Data,Len)
#define Digest_Crc_8(Data,Len)  Crc_8(0,Data,Len)
#define Crc32_Digest(Data,Len,Buf)  Unsigned_To_Four(Crc_32(0,Data,Len),(Buf))
#define Crc16_Digest(Data,Len,Buf)  Unsigned_To_Two(Crc_16(0,Data,Len),(Buf))
#define Crc8_Digest(Data,Len,Buf)   (*(byte_t*)(Buf) = Crc_8(0,Data,Len))

byte_t Crc_8_32(byte_t start, uint_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>24), (byte_t)(val>>16), (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_8(start,q,4); 
  }
#endif
  ;
  
ushort_t Crc_16_32(ushort_t start, uint_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>24), (byte_t)(val>>16), (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_16(start,q,4); 
  }
#endif
  ;

uint_t Crc_32_32(uint_t start, uint_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>24), (byte_t)(val>>16), (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_32(start,q,4); 
  }
#endif
  ;
  
byte_t Crc_8_16(byte_t start, ushort_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_8(start,q,2); 
  }
#endif
  ;

ushort_t Crc_16_16(ushort_t start, ushort_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_16(start,q,2); 
  }
#endif
  ;
  
uint_t Crc_32_16(uint_t start, ushort_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t q[] = { (byte_t)(val>>8), (byte_t)(val) }; 
    return Crc_32(start,q,2); 
  }
#endif
  ;
  
byte_t Crc_8_64(byte_t start, uquad_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    byte_t C = Crc_8_32(start,(uint_t)(val>>32)); 
    return Crc_8_32(C,(uint_t)val); 
  }
#endif
  ;

ushort_t Crc_16_64(ushort_t start, uquad_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    ushort_t C = Crc_16_32(start,(uint_t)(val>>32)); 
    return Crc_16_32(C,(uint_t)val); 
  }
#endif
  ;
  
uint_t Crc_32_64(uint_t start, uquad_t val) 
#ifdef _YO_CRC_BUILTIN
  { 
    uint_t C = Crc_32_32(start,(uint_t)(val>>32)); 
    return Crc_32_32(C,(uint_t)val); 
  }
#endif
  ;

#ifdef _YO_CRC_BUILTIN

  #define CRC32_MCRO_DO1(buf)  crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
  #define CRC32_MCRO_DO2(buf)  CRC32_MCRO_DO1(buf); CRC32_MCRO_DO1(buf);
  #define CRC32_MCRO_DO4(buf)  CRC32_MCRO_DO2(buf); CRC32_MCRO_DO2(buf);
  #define CRC32_MCRO_DO8(buf)  CRC32_MCRO_DO4(buf); CRC32_MCRO_DO4(buf);

  uint_t Crc_32(uint_t crc, void *_buf, int len)

#undef _ADLER32_DO1
#undef _ADLER32_DO2
#undef _ADLER32_DO4
#undef _ADLER32_DO8
#undef _ADLER32_DO16

#endif /* _YO_CRC_BUILTIN */

#endif /* C_once_A1549AAE_F443_4982_AFD4_F5BE02C14DE6 */

#define C_once_DD56FBFA_631C_47CD_B2A4_E6C8932594C8

#include "yoyo.hc"
#include "string.hc"
#include "buffer.hc"

#ifdef _LIBYOYO
#define _YO_CTOKEN_BUILTIN
#endif

enum
  {
      YO_CTOKEN_ERR         = -2,
      YO_CTOKEN_END         = -1,
      YO_CTOKEN_DIGITS      = __FOUR_CHARS('D','I','G','T'),

      YO_CTOKEN_ELS         = __FOUR_CHARS(' ','.','.','.'),
      YO_CTOKEN_EQUAL       = __FOUR_CHARS(' ',' ','=','='),
      YO_CTOKEN_NSPACE      = __FOUR_CHARS(' ',' ',':',':'),
      YO_CTOKEN_NEG_SET     = __FOUR_CHARS(' ',' ','~','='),
      YO_CTOKEN_NOT_SET     = __FOUR_CHARS(' ',' ','!','='),
  };

typedef struct _YO_CTOKMR
  {
    char *m;
    int lineno;
    int charno;
  } YO_CTOKMR;
  
typedef struct _YO_CTOKST
  {
    char *pS;
    char *pE;
    char *pI;
    char *source;
    int lineno;
    int charno;

    YO_CTOKMR last;
    YO_CTOKMR prelast;
  } YO_CTOKST;

void Ctok_Init(YO_CTOKST *a, char *S, char *E, char *source)
#ifdef _YO_CTOKEN_BUILTIN
  {
    memset(a,0,sizeof(*a));
    a->pI = a->pS = S;
    a->pE = E;
    a->source = source;
    a->lineno = 0;
    a->charno = 0;
  }  
#endif
  ;
  
int Ctok_GetXchr(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
    if ( a->pI != a->pE )
      {
        if ( *a->pI == '\n' ) 
          { ++a->lineno; a->charno = 1; } 
        else 
          ++a->charno;
        return *a->pI++;
      }
    return -1;
  }
#endif
  ;
  
int Ctok_SkipXchrUntil(char c, YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    for (;;)
      {
        STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
        if ( a->pE == a->pI )
          return 0;
        if ( *a->pI != c )

        else
          return c;
      }
  }
#endif
  ;
  
int Ctok_GetXchrIfIs(char c, YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
    if ( a->pE == a->pI || *a->pI != c )
      return 0;
    ++a->pI;
    return c;
  }
#endif
  ;
  
int Ctok_GetXchrIfIs_Rep(char c, YO_CTOKST *a, int no)
#ifdef _YO_CTOKEN_BUILTIN
  {
    int i;
    STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
    if ( a->pE-a->pI < no )
      return 0;
    for ( i = 0; i < no; ++i )
      if ( a->pI[i] != c ) 
        return 0;
    a->pI += no;
    return c;
  }
#endif
  ;
  
void Ctok_Stepback(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
    if ( a->pI != a->pS ) 
      {
        --a->pI;
        if ( *a->pI == '\n' ) --a->lineno;
      }
  }
#endif
  ;
    
int Ctok_Hasmore(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    STRICT_REQUIRE( a->pI <= a->pE && a->pI >= a->pS );
    return a->pE - a->pI;
  }
#endif
  ;
    
void Ctok_Skip_Spaces(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    while ( a->pI != a->pE && ( *a->pI == ' ' || *a->pI == '\t' || *a->pI == '\n' || *a->pI == '\r' ) )
      Ctok_GetXchr(a);
  }
#endif
  ;
  
void Ctok_Mark(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  { 
    Ctok_Skip_Spaces(a);
    a->prelast = a->last;
    a->last.lineno = a->lineno;
    a->last.charno = a->charno;
    a->last.m = a->pI;
  }
#endif
  ;
  
void Ctok_Backmark(YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  { 
    if ( a->last.m )
     {
       a->pI = a->last.m;
       a->charno = a->last.charno;
       a->lineno = a->last.lineno;
      }
    a->last = a->prelast;
    memset(&a->prelast,0,sizeof(a->prelast));
  }
#endif
  ;
  
#define Ctok_Token(Area,Buf) Ctok_Token_(Area,Buf,0,0)
#define Ctok_Token_Local(Area,Buf,Plen) Ctok_Token_(Area,Buf,Plen,1)
#define Ctok_Token_Srcref(Area,Pptr,Plen) Ctok_Token_(Area,Pptr,Plen,2)

int Ctok_Token_(YO_CTOKST *a, void *dst, void *opt, int srccp)
#ifdef _YO_CTOKEN_BUILTIN
  {
    int tk;
    char *S;
    int c;
    STRICT_REQUIRE(a != 0);    
  
  l_repeat:  

      {
      }
    return tk;     
  }
#endif
  ;
  
void Ctok_Expect_Error(char *text,YO_CTOKST *a)
#ifdef _YO_CTOKEN_BUILTIN
  {
    __Raise_Format(YO_ERROR_SYNTAX,("synax error: %s at %s:%d:%d"
                          ,text ,a->source ,a->lineno ,a->charno) );
  }
#endif
  ;
  
char *Ctok_To_String(int tok)
#ifdef _YO_CTOKEN_BUILTIN
  {
    if ( tok > 30 && tok < 128 ) return Str_Copy_L((char*)&tok,1);
    return __Format("token(%4s)",&tok);
  }
#endif
  ;
  
void Ctok_Expect(int comp, char *p, YO_CTOKST *a, YO_BUFFER *r)
#ifdef _YO_CTOKEN_BUILTIN
  {
    int t;
    Ctok_Mark(a);
    t = Ctok_Token(a,r);
    if ( t != comp || ( p && !!strcmp(r->at,p) ) ) 
      {
        Ctok_Backmark(a);
        Ctok_Expect_Error(__Format("expected %s",Ctok_To_String(comp)),a);
      }
  }
#endif
  ;
  
int Ctok_GetIfIs(int comp, char *p, YO_CTOKST *a, YO_BUFFER *r)
#ifdef _YO_CTOKEN_BUILTIN
  {
    int t;
    Ctok_Mark(a);
    t = Ctok_Token(a,r);
    if ( t != comp || ( p && !!strcmp(r->at,p) ) ) 
      {
        Ctok_Backmark(a);

*/

#ifndef C_once_A998DD5F_3579_4977_B115_DCCE42423C49
#define C_once_A998DD5F_3579_4977_B115_DCCE42423C49

#ifdef _LIBYOYO
#define _YO_DATETIME_BUILTIN
#endif

#include "yoyo.hc"

typedef quad_t datetime_t;

#define Get_Curr_Date()        ((uint_t)(Current_Gmt_Datetime()>>32))
#define Get_Curr_Datetime()    Current_Gmt_Datetime()
#define Get_Posix_Datetime(Dt) Timet_Of_Datetime(Dt)
#define Get_Gmtime_Datetime(T) Gmtime_Datetime(T)
#define Get_System_Useconds()  System_Useconds()
#define Get_System_Millis()    (Get_System_Useconds()/1000)

#define System_Millis() (System_Useconds()/1000)
quad_t System_Useconds()
#ifdef _YO_DATETIME_BUILTIN
  {
  #ifdef __windoze
    SYSTEMTIME systime = {0};
    FILETIME   ftime;
    quad_t Q;
    GetSystemTime(&systime);
    SystemTimeToFileTime(&systime,&ftime);
    Q = ((quad_t)ftime.dwHighDateTime << 32) + (quad_t)ftime.dwLowDateTime;
    Q -= 116444736000000000LL; /* posix epoche */
    return Q/10;
  #else
    struct timeval tv = {0};
    gettimeofday(&tv,0);
    return  ( (quad_t)tv.tv_sec * 1000*1000 + (quad_t)tv.tv_usec );
  #endif
  }
#endif
  ;
  
uint_t Get_Mclocks()
#ifdef _YO_DATETIME_BUILTIN
  {
    double c = clock();
    return (uint_t)((c/CLOCKS_PER_SEC)*1000);
  }
#endif
  ;

double Get_Sclocks()
#ifdef _YO_DATETIME_BUILTIN
  {
    double c = clock();
    return c/CLOCKS_PER_SEC;
  }
#endif
  ;

quad_t Tm_To_Datetime(struct tm *tm,int msec)
#ifdef _YO_DATETIME_BUILTIN
  {
    uint_t dt = (((uint_t)tm->tm_year+1900)<<16)|(((uint_t)tm->tm_mon+1)<<8)|tm->tm_mday;
    uint_t mt = ((uint_t)tm->tm_hour<<24)|(uint_t)(tm->tm_min<<16)|((uint_t)tm->tm_sec<<8)|((msec/10)%100);
    return ((quad_t)dt << 32)|(quad_t)mt;
  }
#endif
  ;

#define Gmtime_Datetime(T) _Gmtime_Datetime(T,0)
quad_t _Gmtime_Datetime(time_t t, int ms)
#ifdef _YO_DATETIME_BUILTIN
  {
    struct tm *tm;
    tm = gmtime(&t);
    return Tm_To_Datetime(tm,ms);
  }
#endif
  ;

#define Local_Datetime(T) _Local_Datetime(T,0)
quad_t _Local_Datetime(time_t t, int ms)
#ifdef _YO_DATETIME_BUILTIN
  {
    struct tm *tm;
    tm = localtime(&t);
    return Tm_To_Datetime(tm,ms);
  }
#endif
  ;

quad_t Current_Gmt_Datetime()
#ifdef _YO_DATETIME_BUILTIN
  {
    quad_t usec = Get_System_Useconds();
    return _Gmtime_Datetime((time_t)(usec/1000000),(int)((usec/1000)%1000));
  }
#endif
  ;

quad_t Current_Local_Datetime()
#ifdef _YO_DATETIME_BUILTIN
  {
    quad_t usec = Get_System_Useconds();
    return _Local_Datetime((time_t)(usec/1000000),(int)((usec/1000)%1000));
  }
#endif
  ;

#define Dt_Hour(Dt) ((int)((Dt)>>24)&0x0ff)
#define Dt_Min(Dt)  ((int)((Dt)>>16)&0x0ff)
#define Dt_Sec(Dt)  ((int)((Dt)>> 8)&0x0ff)
#define Dt_Msec(Dt) ((int)((Dt)>> 0)&0x0ff)
#define Dt_Year(Dt) ((int)((Dt)>>(32+16))&0x0ffff)
#define Dt_Mon(Dt)  ((int)((Dt)>>(32+ 8))&0x0ff)
#define Dt_Mday(Dt) ((int)((Dt)>>(32+ 0))&0x0ff)

quad_t Get_Datetime(uint_t year, uint_t month, uint_t day, uint_t hour, uint_t minute, uint_t segundo )
#ifdef _YO_DATETIME_BUILTIN
  {
    uint_t dt = ((year%0x0ffff)<<16)|((month%13)<<8)|(day%32);
    uint_t mt = ((hour%24)<<24)|((minute%60)<<16)|((segundo%60)<<8);
    return ((quad_t)dt << 32)|(quad_t)mt;
  }
#endif
  ;

time_t Timet_Of_Datetime(quad_t dtime)
#ifdef _YO_DATETIME_BUILTIN
  {
    struct tm tm;
    memset(&tm,0,sizeof(tm));
    tm.tm_year = Dt_Year(dtime)-1900;
    tm.tm_mon  = Dt_Mon(dtime)-1;
    tm.tm_mday = Dt_Mday(dtime);
    tm.tm_hour = Dt_Hour(dtime);
    tm.tm_min  = Dt_Min(dtime);
    return mktime(&tm);
  }
#endif
  ;

#ifdef __windoze
  void Timet_To_Filetime(time_t t, FILETIME *pft)
# ifdef _YO_DATETIME_BUILTIN
    {
      quad_t ll = (quad_t)t * 10000000 + 116444736000000000LL;
      pft->dwLowDateTime = (DWORD)ll;
      pft->dwHighDateTime = (DWORD)(ll >> 32);
    }
# endif
    ;
  #define Timet_To_Largetime(T,Li) Timet_To_Filetime(T,(FILETIME*)(Li))
#endif /*__windoze*/

#endif /* C_once_A998DD5F_3579_4977_B115_DCCE42423C49 */

*/

#ifndef C_once_1ABAFC81_AD6E_4869_8891_EEE28BC64BF4
#define C_once_1ABAFC81_AD6E_4869_8891_EEE28BC64BF4

#ifdef _LIBYOYO
#define _YO_DEBUGIT_BUILTIN
#endif

#include "yoyo.hc"
#include "winreg.hc"

#ifdef _MSC_VER
# define Debug_Break() __debugbreak()    
#elif defined __GNUC__
# define Debug_Break() __builtin_trap()    
#else
# define Debug_Break() raise(SIGTRAP)
#endif

void Debug_It()
#ifdef _YO_DEBUGIT_BUILTIN
  {
#ifdef __windoze
    char ae[128] = {0};
    __Auto_Release
      {
        YO_WINREG *h = Open_Local_Machine_Subkey("Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug");
        char *S = WinReg_Query_String(h,"Debugger");
        snprintf(ae,127,S,GetCurrentProcessId(),0);
      }
    WinExec(ae,0);
    Sleep(3000);
#endif
    Debug_Break();    
  }
#endif
  ;
  
#endif /*C_once_1ABAFC81_AD6E_4869_8891_EEE28BC64BF4*/

*/

#ifndef C_once_38B1FFE7_1462_42EB_BABE_AA8E0BE62203
#define C_once_38B1FFE7_1462_42EB_BABE_AA8E0BE62203

#ifdef _LIBYOYO
#define _YO_DICTO_BUILTIN
#endif

#include "yoyo.hc"
#include "crc.hc"
#include "buffer.hc"
#include "array.hc"

typedef struct _YO_DICTO_REC
  {
    struct _YO_DICTO_REC *next;
    void *ptr;
    byte_t hashcode;
    char key[1];
  } YO_DICTO_REC;

typedef struct _YO_DICTO
  {
    struct _YO_DICTO_REC **table; 
    int count;
    int width;
  } YO_DICTO;


#define Dicto_Hash_1(Key) Crc_8_Of_Cstr(Key)
#define Dicto_Count(Dicto) ((int)((YO_DICTO*)(Dicto))->count+0)

void Dicto_Rehash(YO_DICTO *o);

#ifdef _YO_DICTO_BUILTIN  
int Dicto_Width_Values[] = {5,11,23,47,97,181,256};
#endif

YO_DICTO_REC **Dicto_Backet(YO_DICTO *o, byte_t hashcode, char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    YO_DICTO_REC **nrec;
    
    if ( !o->table )
      {
        o->width = Dicto_Width_Values[0];
        o->table = Yo_Malloc_Npl(o->width*sizeof(void*));
        memset(o->table,0,o->width*sizeof(void*));
      }

      }
    
    return nrec;
  }
#endif
  ;

YO_DICTO_REC *Dicto_Allocate(char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    int keylen = strlen(key);
    YO_DICTO_REC *Q = Yo_Malloc_Npl(sizeof(YO_DICTO_REC) + keylen);
    memcpy(Q->key,key,keylen+1);
    Q->hashcode = Dicto_Hash_1(key);
    Q->next = 0;
    Q->ptr = 0;
    return Q;
  }
#endif
  ;

void *Dicto_Get(YO_DICTO *o, char *key, void *dflt)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        YO_DICTO_REC *Q = *Dicto_Backet(o,hashcode,key);
        if ( Q )
          return Q->ptr;
      }
    return dflt;
  }
#endif
  ;

void *Dicto_Get_Key_Ptr(YO_DICTO *o, char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        YO_DICTO_REC *Q = *Dicto_Backet(o,hashcode,key);
        if ( Q )
          return Q->key;
      }
    return 0;
  }
#endif
  ;

int Dicto_Has(YO_DICTO *o, char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        if ( *Dicto_Backet(o,hashcode,key) )
          return 1;
      }
    return 0;
  }
#endif
  ;

void *Dicto_Put(YO_DICTO *o, char *key, void *val)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        YO_DICTO_REC **Q = Dicto_Backet(o,hashcode,key);
        if ( *Q )
          {
            YO_DICTO_REC *p = *Q;
            void *self = o;
            void (*destructor)(void*) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
            if ( destructor )
              (*destructor)(p->ptr);
            p->ptr = val;
            key = (*Q)->key;
          }

      }
    else
      return 0;
  }
#endif
  ;

void Dicto_Del(YO_DICTO *o, char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        YO_DICTO_REC **Q = Dicto_Backet(o,hashcode,key);
        if ( *Q )
          {
            YO_DICTO_REC *p = *Q;
            void *self = o;
            void (*destructor)(void*) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
            if ( destructor )
              (*destructor)(p->ptr);
            *Q = (*Q)->next;
            free(p);
            STRICT_REQUIRE ( o->count >= 1 );
            --o->count;
          }
      }
  }
#endif
  ;

/* returns unmanaged value */
void *Dicto_Take_Npl(YO_DICTO *o, char *key)
#ifdef _YO_DICTO_BUILTIN  
  {
    if ( key )
      {
        byte_t hashcode = Dicto_Hash_1(key);
        YO_DICTO_REC **Q = Dicto_Backet(o,hashcode,key);
        if ( *Q )
          {
            YO_DICTO_REC *p = *Q;
            void *ret = p->ptr;
            *Q = (*Q)->next;
            free(p);
            STRICT_REQUIRE ( o->count >= 1 );
            --o->count;
            return ret;
          }
      }
    return 0;
  }
#endif
  ;

void *Dicto_Take(YO_DICTO *o, char *key)
#ifdef _YO_ARRAY_BUILTIN
  {
    void *self = o;
    void (*destruct)(void *) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,YO_RAISE_ERROR);
    void *Q = Dicto_Take_Npl(o,key);
    
    if ( Q )
      Yo_Pool_Ptr(Q,destruct);
      
    return Q;
  }
#endif
  ;

void Dicto_Clear(YO_DICTO *o)
#ifdef _YO_DICTO_BUILTIN  
  {
    int i;
    void *self = o;
    void (*destructor)(void*) = Yo_Find_Method_Of(&self,Oj_Destruct_Element_OjMID,0);
    
    if ( o->table )
      for ( i = 0; i < o->width; ++i )
        while ( o->table[i] )
          {
            YO_DICTO_REC *Q = o->table[i];
            o->table[i] = Q->next;
            if ( destructor )
              (*destructor)(Q->ptr);
            free(Q);
          }

    if ( o->table ) free( o->table );
    o->table = 0;
    o->width = 0;
    o->count = 0;      
  }
#endif
  ;

#ifdef _YO_DICTO_BUILTIN  
void Dicto_Rehash(YO_DICTO *o)
  {
    if ( o->table && o->count )
      {
        int i;
        int width = 256;
        YO_DICTO_REC **table;
        
        for ( i = 0; Dicto_Width_Values[i] < 256; ++i )
          if ( o->count <= Dicto_Width_Values[i] + Dicto_Width_Values[i]/2  )
            {
              width = Dicto_Width_Values[i]; 
              break;
            }
        
        if ( width > o->width ) 
          {
            table = Yo_Malloc_Npl(width*sizeof(void*));
            memset(table,0,width*sizeof(void*));
        
            for ( i = 0; i < o->width; ++i )
              while ( o->table[i] )
                {
                  YO_DICTO_REC *Q = o->table[i];
                  o->table[i] = Q->next;
                  Q->next = table[Q->hashcode%width];
                  table[Q->hashcode%width] = Q;
                }
      
            free(o->table);
            o->width = width;
            o->table = table;    
          }
      }
  }
#endif
  ;

void Dicto_Destruct(YO_DICTO *o)
#ifdef _YO_DICTO_BUILTIN  
  {
    Dicto_Clear(o);
    Yo_Object_Destruct(o);
  }
#endif
  ;

void *Dicto_Refs(void)
#ifdef _YO_DICTO_BUILTIN  
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID, Dicto_Destruct},
        {Oj_Destruct_Element_OjMID, Yo_Unrefe},
        {0}};
    YO_DICTO *dicto = Yo_Object(sizeof(YO_DICTO),funcs);
    return dicto;
  }
#endif
  ;

void *Dicto_Ptrs(void)
#ifdef _YO_DICTO_BUILTIN  
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID, Dicto_Destruct},
        {Oj_Destruct_Element_OjMID, free},
        {0}};
    YO_DICTO *dicto = Yo_Object(sizeof(YO_DICTO),funcs);
    return dicto;
  }
#endif
  ;

void *Dicto_Init(void)
#ifdef _YO_DICTO_BUILTIN  
  {
    YO_DICTO *dicto = Yo_Object_Dtor(sizeof(YO_DICTO),Dicto_Destruct);
    return dicto;
  }
#endif
  ;

void Dicto_Apply(YO_DICTO *o,void (*filter)(char *,void *,void *),void *state)  
#ifdef _YO_DICTO_BUILTIN  
  {
    int i;
    YO_DICTO_REC *nrec;
    if ( o && o->table ) 
      for ( i = 0; i < o->width; ++i )
        {      
          nrec = o->table[i];
          while ( nrec )
            {
              filter(nrec->key,nrec->ptr,state);
              nrec = nrec->next;
            }  
        }
  }
#endif
  ;

void _Dicto_Filter_Push_Value(char *key, void *value, YO_ARRAY *a)
#ifdef _YO_DICTO_BUILTIN  
  {
    Array_Push(a,value);
  }
#endif
  ;
    
YO_ARRAY *Dicto_Values(YO_DICTO *o)
#ifdef _YO_DICTO_BUILTIN  
  {
    YO_ARRAY *a = Array_Void();
    Dicto_Apply(o,_Dicto_Filter_Push_Value,a);
    return a;
  }
#endif
  ;
    
void _Dicto_Filter_Push_Key(char *key, void *value, YO_ARRAY *a)
#ifdef _YO_DICTO_BUILTIN  
  {
    Array_Push(a,key);
  }
#endif
  ;
    
YO_ARRAY *Dicto_Keys(YO_DICTO *o)
#ifdef _YO_DICTO_BUILTIN  
  {
    YO_ARRAY *a = Array_Void();
    Dicto_Apply(o,_Dicto_Filter_Push_Key,a);
    return a;
  }
#endif
  ;
  
typedef void (*dicto_format_printer_t)(YO_BUFFER *bf,void *S);

char *Dicto_Format(YO_DICTO *o, dicto_format_printer_t print, YO_BUFFER *_bf, int pretty)
#ifdef _YO_DICTO_BUILTIN  
  {
    int start = 0, i, j=0;
    YO_BUFFER *bf = _bf;
    YO_DICTO_REC *nrec;

    if ( !bf ) bf = Buffer_Init(0);
    start = bf->count;
    
    Buffer_Fill_Append(bf,'{',1);
    if ( pretty )
      Buffer_Fill_Append(bf,'\n',1); 

*/

#ifndef C_once_E9479D04_5D69_4A1A_944F_0C99A852DC0B
#define C_once_E9479D04_5D69_4A1A_944F_0C99A852DC0B

#ifdef _LIBYOYO
#define _YO_FILE_BUILTIN
#endif

#include "yoyo.hc"
#include "string.hc"
#include "buffer.hc"
#include "random.hc"

#ifndef __windoze
# include <dirent.h>
# include <sys/file.h>
#endif

#ifdef _FILEi32
  typedef long file_offset_t;
#else
  typedef quad_t file_offset_t;
#endif

enum { YO_FILE_COPY_BUFFER_SIZE = 4096, };

#ifdef _YO_FILE_BUILTIN
# define _YO_FILE_BUILTIN_CODE(Code) Code
# define _YO_FILE_EXTERN
#else
# define _YO_FILE_BUILTIN_CODE(Code)
# define _YO_FILE_EXTERN extern
#endif

#ifdef __windoze
enum { YO_PATH_SEPARATOR = '\\' };
#else
enum { YO_PATH_SEPARATOR = '/' };
#endif

void File_Check_Error(char *op, FILE *f, char *fname, int look_to_errno)
#ifdef _YO_FILE_BUILTIN
  {
    int err = 0;
    char *errS = 0;
    
    if ( look_to_errno )
      {
        if ( (err = errno) ) 
          errS = strerror(err);
      }
    else if ( f && !feof(f) && ( err = ferror(f) ) )
      {
        errS = strerror(err);
        clearerr(f);
      }
    
    if (err)
      __Raise_Format(YO_ERROR_IO,("%s failed on file '%s': %s",op,fname,errS));
  }
#endif
  ;

#define Raise_If_File_Error(Op,Fname) File_Check_Error(Op,0,Fname,1)

char *Path_Basename(char *path)
#ifdef _YO_FILE_BUILTIN
  {
    char *ret = path;
    if ( path )
      {
        char *p = strrchr(path,'/');
      #ifdef __windoze
        char *p2 = strrchr(path,'\\');
        if ( !p || p < p2 ) p = p2;
      #endif
        if ( p )
          ret = Str_Copy(p+1);
      }
    return ret;
  }
#endif
  ;

char *Path_Dirname(char *path)
#ifdef _YO_FILE_BUILTIN
  {
    char *ret = 0;
    if ( path )
      {
        char *p = strrchr(path,'/');
      #ifdef __windoze
        char *p2 = strrchr(path,'\\');

          }
      }
    return ret;
  }
#endif
  ;

char *Temp_Directory()
#ifdef _YO_FILE_BUILTIN
  {
    enum { tmp_len = 512 };
    char *ptr = 0;
    __Auto_Ptr(ptr)
      {
      #ifdef __windoze
        wchar_t *tmp = __Malloc((tmp_len+1)*sizeof(wchar_t));
        GetTempPathW(tmp_len+1,tmp);
        ptr = Str_Unicode_To_Utf8(tmp);
      #else
        char *tmp = getenv("TEMP");
        if ( !tmp ) tmp = "/tmp"
        ptr = Str_Copy(tmp);
      #endif
      }
    return ptr;
  }
#endif
  ;
    
char *Current_Directory()
#ifdef _YO_FILE_BUILTIN
  {
    enum { tmp_len = 512 };
    char *ptr = 0;
    __Auto_Ptr(ptr)
      {
      #ifdef __windoze
        wchar_t *tmp = __Malloc((tmp_len+1)*sizeof(wchar_t));
        ptr = Str_Unicode_To_Utf8(_wgetcwd(tmp,tmp_len));
      #else
        char *tmp = __Malloc(tmp_len+1);
        ptr = Str_Copy(getcwd(tmp,tmp_len),-1);
      #endif
      }
    return ptr;
  }
#endif
  ;

void Change_Directory(char *dirname)
#ifdef _YO_FILE_BUILTIN
  {
    __Auto_Release
      {
        int err;
      #ifdef __windoze
        wchar_t *tmp = Str_Utf8_To_Unicode(dirname);
        err = _wchdir(tmp);
      #else
        err = chdir(dirname);
      #endif
        if ( err == - 1 )
          Raise_If_File_Error("chdir",dirname);
      }
  }
#endif
  ;
  
char *Path_Normilize_Npl_(char *path, int sep)
#ifdef _YO_FILE_BUILTIN
  {
    int i = 0, ln = strlen(path);
    char *S = __Malloc_Npl(ln+1);
    *S = 0;
    
    while ( *path )
      {

    if ( i && S[i-1] == sep ) S[--i] = 0;
    
    return S;
  }
#endif
  ;

#define Path_Normilize_Npl(S) Path_Normilize_Npl_(S,YO_PATH_SEPARATOR)
#define Path_Normilize(S) __Pool(Path_Normilize_Npl(S))
#define Path_Normposix_Npl(S) Path_Normilize_Npl_(S,'/')
#define Path_Normposix(S) __Pool(Path_Normilize_Npl(S))

char *Path_Unique_Name(char *dirname,char *pfx, char *sfx)
#ifdef _YO_FILE_BUILTIN
  {
  #ifdef __windoze
    char DELIMITER[] = "\\";
  #else
    char DELIMITER[] = "/";
  #endif
    char unique[2+4+6] = {0};

    else
      return Str_Join_3(0,(pfx?pfx:""),out,(sfx?sfx:""));
  }
#endif
  ;

char *Path_Join(char *dir, char *name)
#ifdef _YO_FILE_BUILTIN
  {
  #ifdef __windoze
    enum { DELIMITER = '\\' };
  #else
    enum { DELIMITER = '/' };
  #endif
    if ( dir && *dir )

    else
      return Str_Copy(name);
  }
#endif
  ;

char *Path_Suffix(char *path)
#ifdef _YO_FILE_BUILTIN
  {
    char *ret = 0;
    char *p = strrchr(path,'.');
    if ( p )
      {
        char *p1 = strrchr(path,'/');
        if ( p1 && p1 > p ) p = p1;

      ret = Str_Copy(p);
    return ret;
  }
#endif
  ;

char *Path_Unsuffix(char *path)
#ifdef _YO_FILE_BUILTIN
  {
    char *ret = 0;
    char *p = strrchr(path,'.');
    if ( p )
      {
        char *p1 = strrchr(path,'/');
        if ( p1 && p1 > p ) p = p1;

      ret = Str_Copy_L(path,p-path);
    return ret;
  }
#endif
  ;
  
char *Path_Fullname(char *path)
#ifdef _YO_FILE_BUILTIN
  {
  #ifdef __windoze
    if ( path )
      {
        wchar_t *foo;
        char *ret = 0;
        __Auto_Ptr(ret)

      }
  #endif
    return Str_Copy(path);
  }
#endif
  ;

typedef struct _YO_FILE_STATS
  {
    time_t ctime;
    time_t mtime;
    quad_t length;
    
    struct {
      int exists: 1;
      int is_regular: 1;
      int is_tty: 1;
      int is_symlink: 1;
      int is_unisok: 1;
      int is_directory: 1;
      int is_writable: 1;
      int is_readable: 1;
      int is_executable: 1;
    } f;
  
  } YO_FILE_STATS;

#ifdef __windoze
  #if !defined _FILEi32  
    typedef struct __stat64 _YO_stat;
  #else
    typedef struct _stat _YO_stat;
  #endif
  #if !defined S_IWUSR 
    enum 
      { 
        S_IWUSR = _S_IWRITE,
        S_IRUSR = _S_IREAD,
        S_IXUSR = _S_IEXEC,
      };
  #endif  
#else
  typedef struct stat _YO_stat;
#endif        

YO_FILE_STATS *File_Translate_Filestats(_YO_stat *fst,YO_FILE_STATS *st,int exists)
#ifdef _YO_FILE_BUILTIN
  {
    if ( !st ) st = __Malloc(sizeof(YO_FILE_STATS));
    memset(st,0,sizeof(*st));
    st->f.exists       = exists;
    st->f.is_regular   = !!((fst->st_mode&S_IFMT) & S_IFREG);
    st->f.is_directory = !!((fst->st_mode&S_IFMT) & S_IFDIR);
  #ifndef __windoze  
    st->f.is_symlink   = !!((fst->st_mode&S_IFMT) & S_IFLNK);    
    st->f.is_unisok    = !!((fst->st_mode&S_IFMT) & S_IFSOCK);
  #endif  
    st->f.is_writable  = (fst->st_mode&S_IWUSR) != 0;
    st->f.is_readable  = (fst->st_mode&S_IRUSR) != 0;
    st->f.is_executable = (fst->st_mode&S_IXUSR) != 0;
    st->length = fst->st_size;
    st->ctime  = fst->st_ctime;
    st->mtime  = fst->st_mtime;
    
    return st;
  }
#endif
  ;

YO_FILE_STATS *File_Get_Stats(char *name,YO_FILE_STATS *st,int ignorerr)
#ifdef _YO_FILE_BUILTIN
  {
    _YO_stat fst = {0};
    int err;
  #ifdef __windoze
    wchar_t *uni_name = Str_Utf8_To_Unicode(name);
    #ifndef _FILEi32  
      err = _wstat64(uni_name,&fst);
    #else
      err = _wstat(uni_name,&fst);

        st = File_Translate_Filestats(&fst,st,!err);
      }
    else if ( err && !ignorerr )              
      {
        int eno = errno;
        if ( st ) memset(st,0,sizeof(*st));
        if ( eno == ENOENT || eno == ENOTDIR )
          __Raise_Format(YO_ERROR_DOESNT_EXIST,("file '%s' does not exist",name));
        File_Check_Error("getting stats",0,name,1); 
      }
    return st;
  }
#endif
  ;

YO_FILE_STATS *File_Get_Stats_Reuse(char *name, YO_FILE_STATS **stp)
#ifdef _YO_FILE_BUILTIN
  {
    if ( stp && *stp ) 
      return *stp;
    else
      {
        YO_FILE_STATS *st = File_Get_Stats(name,0,0);
        if ( stp ) *stp = st;
        return st;
      }
  }
#endif
  ;

time_t File_Ctime(char *name) 
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->ctime;});
time_t File_Mtime(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->mtime;});
quad_t File_Length(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->length;});
int File_Exists(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,1)->f.exists;});
int File_Is_Regular(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->f.is_regular;});
int File_Is_Directory(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->f.is_directory;});
int File_Is_Writable(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->f.is_writable;});
int File_Is_Readable(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->f.is_readable;});
int File_Is_Executable(char *name)
  _YO_FILE_BUILTIN_CODE({YO_FILE_STATS st={0}; return File_Get_Stats(name,&st,0)->f.is_executable;});

void Delete_Directory(char *name)
#ifdef _YO_FILE_BUILTIN
  {
    YO_FILE_STATS st;
    if ( File_Get_Stats(name,&st,1)->f.is_directory )
      {
      #ifdef __windoze
        if ( _wrmdir(Str_Utf8_To_Unicode(name)) < 0 )
      #else
        if ( rmdir(name) < 0 )
      #endif  
          File_Check_Error("rmdir",0,name,1);
      }
  }
#endif
  ;

void Create_Directory(char *name)
#ifdef _YO_FILE_BUILTIN
  {
    YO_FILE_STATS st;
    if ( !File_Get_Stats(name,&st,1)->f.is_directory )
      {
      #ifdef __windoze
        if ( _wmkdir(Str_Utf8_To_Unicode(name)) < 0 )
      #else
        if ( mkdir(name,0755) < 0 )
      #endif  
          File_Check_Error("mkdir",0,name,1);
      }
  }
#endif
  ;

void Create_Directory_In_Depth(char *name)
#ifdef _YO_FILE_BUILTIN
  {
    int nL = name ? strlen(name) : 0;
    if ( nL 
        && !(nL == 2 && name[1] == ':')  
        && !(nL == 1 && (name[0] == '/' || name[0] == '\\') ))
      {
        Create_Directory_In_Depth(Path_Dirname(name));
        Create_Directory(name);
      }
  }
#endif
  ;

void Create_Required_Dirs(char *name)
#ifdef _YO_FILE_BUILTIN
  {
    __Auto_Release
      {
        char *dirpath = Path_Dirname(name);
        Create_Directory_In_Depth(dirpath);
      }
  }
#endif
  ;

enum _YO_DIRLIST_FLAGS
  {
    FILE_LIST_ALL = 0,
    FILE_LIST_DIRECTORIES = 1,
    FILE_LIST_FILES = 2,
  };

YO_ARRAY *File_List_Directory(char *dirname, unsigned flags)
#ifdef _YO_FILE_BUILTIN
  {
  #ifdef __windoze
    WIN32_FIND_DATAW fdtw;
    HANDLE hfnd;
  #else
    DIR *dir;
  #endif

#ifdef __windoze
#define utf8_unlink(S) _wunlink(Str_Utf8_To_Unicode(S));
#else
#define utf8_unlink(S) unlink(S)
#endif

void File_Unlink(char *name, int force)
#ifdef _YO_FILE_BUILTIN
  {
    YO_FILE_STATS st;
    int i, err = 0;
    
    __Auto_Release
      {
        File_Get_Stats(name,&st,0);
    
        if ( st.f.exists )
          {
            if ( st.f.is_directory && force )
              {
                YO_ARRAY *L = File_List_Directory(name,0);
                for ( i = 0; i < L->count; ++i )
                  File_Unlink(Path_Join(name,L->at[i]),force);
                Delete_Directory(name);
              }
            else
              err = utf8_unlink(name);
          }
      
        if ( err < 0 )
          File_Check_Error("unlink",0,name,1); 
      }
  }
#endif
  ;

void File_Rename(char *old_name, char *new_name)
#ifdef _YO_FILE_BUILTIN
  {
    int err = 0;
  #ifdef __windoze
    wchar_t *So = Str_Utf8_To_Unicode(old_name);
    wchar_t *Sn = Str_Utf8_To_Unicode(new_name);
    err = _wrename(So,Sn);
    Yo_Release(Sn);
    Yo_Release(So);
  #else
    err = rename(old_name,new_name);
  #endif
    if ( err < 0 )
      File_Check_Error("rename",0,old_name,1); 
  }
#endif
  ;
  
typedef struct _YO_CFILE
  {
    FILE *fd;
    char *name;
    int shared;
  } YO_CFILE;

int Raise_If_Cfile_Is_Not_Opened(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( !f || !f->fd )
      Yo_Raise(YO_ERROR_IO,
        Yo_Format("file '%s' is already closed",(f?f->name:""))
        ,__Yo_FILE__,__LINE__);
    return 1;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Close_OjMID[] _YO_FILE_BUILTIN_CODE( = "close/@"); 
int Oj_Close(void *f) _YO_FILE_BUILTIN_CODE(
  { return ((int(*)(void*))Yo_Find_Method_Of(&f,Oj_Close_OjMID,YO_RAISE_ERROR))
        (f); });

int Cfile_Close(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( f->fd )
      {
        fclose(f->fd);
        f->fd = 0;
      }
    return 0;
  }
#endif
  ;

int Pfile_Close(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    int ret = 0;
    if ( f->fd )
      {
      #ifdef __windoze
        ret = _pclose(f->fd);
      #else
        ret = pclose(f->fd);
      #endif
        f->fd = 0;
      }
    return ret;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Flush_OjMID[] _YO_FILE_BUILTIN_CODE( = "flush/@"); 
void Oj_Flush(void *f) _YO_FILE_BUILTIN_CODE(
  { ((void(*)(void*))Yo_Find_Method_Of(&f,Oj_Flush_OjMID,YO_RAISE_ERROR))
        (f); });

void Cfile_Flush(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( f->fd )
      if ( fflush(f->fd) )
        {
          File_Check_Error("flush",0,f->name,1); 
        }
  }
#endif
  ;

void Cfile_Destruct(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    Cfile_Close(f);
    free(f->name);
    __Destruct(f);
  }
#endif
  ;

void Pfile_Destruct(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    Pfile_Close(f);
    free(f->name);
    __Destruct(f);
  }
#endif
  ;

YO_FILE_STATS *Cfile_Stats(YO_CFILE *f,YO_FILE_STATS *st)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        _YO_stat fst = {0};
        int err;

      #ifdef __windoze
        #if !defined _FILEi32  
          err = _fstat64(fileno(f->fd),&fst);
        #else
          err = _fstat(fileno(f->fd),&fst);
        #endif
      #else
        err = fstat(fileno(f->fd),&fst);
      #endif        
        if ( err )
          File_Check_Error("getting stats",f->fd,f->name,0); 
        return File_Translate_Filestats(&fst,st,!err);
      }
    return 0;
  };
#endif
  ;

_YO_FILE_EXTERN char Oj_Eof_OjMID[] _YO_FILE_BUILTIN_CODE( = "eof/@"); 
int Oj_Eof(void *f) _YO_FILE_BUILTIN_CODE(
  { return 
      ((int(*)(void*))Yo_Find_Method_Of(&f,Oj_Eof_OjMID,YO_RAISE_ERROR))
        (f); });

int Cfile_Eof(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( f->fd )
      {
        return feof(f->fd);
      }
    return 1;
  }
#endif
  ;

#define Oj_Read_Full(File,Buf,Count) Oj_Read(File,Buf,Count,-1)
_YO_FILE_EXTERN char Oj_Read_OjMID[] _YO_FILE_BUILTIN_CODE( = "read/@*ii"); 
int Oj_Read(void *f,void *buf,int count,int min_count) _YO_FILE_BUILTIN_CODE(
  { return 
      ((int(*)(void*,void*,int,int))Yo_Find_Method_Of(&f,Oj_Read_OjMID,YO_RAISE_ERROR))
        (f,buf,count,min_count); });

int Cfile_Read(YO_CFILE *f, void *buf, int count, int min_count)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        int cc = 0;
        byte_t *d = (byte_t *)buf;
        if ( min_count < 0 ) min_count = count; 
        for ( ; cc < count ; )
          {
            int q = fread(d,1,count-cc,f->fd);
            if ( q <= 0 )
              {
                if ( feof(f->fd) )
                  {
                    if ( cc >= min_count ) 
                      break;
                    else 
                      Yo_Raise(YO_ERROR_IO,
                        Yo_Format("end of file '%s'",f->name), __FILE__,__LINE__);
                  }
                else 
                  File_Check_Error("read",f->fd,f->name,0);
              }
            if ( !q && cc >= min_count) break;
            cc += q;
            d += q;
          }
        return cc;
      }
    return 0;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Read_Line_OjMID[] _YO_FILE_BUILTIN_CODE( = "readline/@"); 
char *Oj_Read_Line(void *f) _YO_FILE_BUILTIN_CODE(
  { return 
      ((void *(*)(void*))Yo_Find_Method_Of(&f,Oj_Read_Line_OjMID,YO_RAISE_ERROR))
        (f); });

char *Cfile_Read_Line(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        int S_len = 0;
        char *S = 0;
        for(;;)
          {

      }
    return 0;
  }
#endif
  ;

#define Oj_Write_Full(File,Buf,Count) Oj_Write(File,Buf,Count,-1)
_YO_FILE_EXTERN char Oj_Write_OjMID[] _YO_FILE_BUILTIN_CODE( = "write/@*ii"); 
int Oj_Write(void *f,void *buf,int count,int min_count) _YO_FILE_BUILTIN_CODE(
  { return 
      ((int(*)(void*,void*,int,int))Yo_Find_Method_Of(&f,Oj_Write_OjMID,YO_RAISE_ERROR))
        (f,buf,count,min_count); });

int Cfile_Write(YO_CFILE *f, void *buf, int count, int min_count)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        int cc = 0;
        char *d = buf;
        for ( ; cc < count ; )
          {

        return cc;
      }
    return 0;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Write_Line_OjMID[] _YO_FILE_BUILTIN_CODE( = "writeline/@*"); 
void Oj_Write_Line(void *f,char *text) _YO_FILE_BUILTIN_CODE(
  { ((void(*)(void*,void*))Yo_Find_Method_Of(&f,Oj_Write_Line_OjMID,YO_RAISE_ERROR))
        (f,text); });

void Cfile_Write_Line(YO_CFILE *f, char *text)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        int Ln = text?strlen(text):0;
        if ( Ln )
          Cfile_Write(f,text,Ln,Ln);
        Cfile_Write(f,"\n",1,1);
        Cfile_Flush(f);
      }
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Tell_OjMID[] _YO_FILE_BUILTIN_CODE( = "tell/@"); 
quad_t Oj_Tell(void *f) _YO_FILE_BUILTIN_CODE(
  { return 
      ((quad_t(*)(void*))Yo_Find_Method_Of(&f,Oj_Tell_OjMID,YO_RAISE_ERROR))
        (f); });

quad_t Cfile_Tell(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        quad_t q = 
        #ifdef __windoze 
          #if !defined _FILEi32  
            _ftelli64(f->fd);

        return q;
      }
    return 0;
  }
#endif
  ;
  
_YO_FILE_EXTERN char Oj_Length_OjMID[] _YO_FILE_BUILTIN_CODE( = "length/@"); 
quad_t Oj_Length(void *f) _YO_FILE_BUILTIN_CODE(
  { return 
      ((quad_t(*)(void*))Yo_Find_Method_Of(&f,Oj_Length_OjMID,YO_RAISE_ERROR))
        (f); });

quad_t Cfile_Length(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        YO_FILE_STATS st = {0};
        return Cfile_Stats(f,&st)->length; 
      }
    return 0;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Available_OjMID[] _YO_FILE_BUILTIN_CODE( = "available/@"); 
quad_t Oj_Available(void *f) _YO_FILE_BUILTIN_CODE(
  { return 
      ((quad_t(*)(void*))Yo_Find_Method_Of(&f,Oj_Available_OjMID,YO_RAISE_ERROR))
        (f); });

quad_t Cfile_Available(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        YO_FILE_STATS st;
        return Cfile_Stats(f,&st)->length - Cfile_Tell(f); 
      }
    return 0;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Read_All_OjMID[] _YO_FILE_BUILTIN_CODE( = "readall/@"); 
YO_BUFFER *Oj_Read_All(void *f)
#ifdef _YO_FILE_BUILTIN
  {
    void *(*readall)(void*) = Yo_Find_Method_Of(&f,Oj_Read_All_OjMID,0);
    if ( readall )
      return readall(f);
    else
      {
        quad_t (*available)(void*) = Yo_Find_Method_Of(&f,Oj_Available_OjMID,0);
        int (*read)(void*,void*,int,int) = Yo_Find_Method_Of(&f,Oj_Read_OjMID,YO_RAISE_ERROR);
        void *L;
        if ( available )
          {
            quad_t len = available(f);
            if ( len > INT_MAX )
              __Raise(YO_ERROR_IO,"file to big to be read in one pass");
            L = Buffer_Init((int)len);
            if ( len )
              read(f,Buffer_Begin(L),(int)len,(int)len);
          }
        else
          {
            int (*eof)(void*) = Yo_Find_Method_Of(&f,Oj_Eof_OjMID,YO_RAISE_ERROR);

          }
        return L;
      }
  }
#endif
  ;

YO_BUFFER *Cfile_Read_All(YO_CFILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        YO_BUFFER *L;
        quad_t len = Cfile_Available(f);
        if ( len > INT_MAX )
          Yo_Raise(YO_ERROR_IO,
            "file to big to be read in one pass",__Yo_FILE__,__LINE__);
        L = Buffer_Init(0);
        while ( len ) 
          /* windoze text mode reads less then available, so we need to read carefully*/
          {
            Buffer_Grow_Reserve(L,L->count+(int)len);
            L->count += Cfile_Read(f,L->at+L->count,(int)len,0);
            L->at[L->count] = 0;
            len = Cfile_Available(f);
          }
        return L;
      }
    return 0;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Seek_OjMID[] _YO_FILE_BUILTIN_CODE( = "seek/@qi"); 
quad_t Oj_Seek(void *f, quad_t pos, int whence) _YO_FILE_BUILTIN_CODE(
  { return 
      ((quad_t (*)(void*,quad_t,int whence))Yo_Find_Method_Of(&f,Oj_Seek_OjMID,YO_RAISE_ERROR))
        (f,pos,whence); });

quad_t Cfile_Seek(YO_CFILE *f, quad_t pos, int whence)
#ifdef _YO_FILE_BUILTIN
  {
    quad_t old = Cfile_Tell(f);
    if ( old < 0 ) return -1;
    
    if ( Raise_If_Cfile_Is_Not_Opened(f) )
      {
        int q = 

        return old;
      }
    return 0;
  }
#endif
  ;

YO_CFILE *Cfile_Object(FILE *fd, char *name, int share)
#ifdef _YO_FILE_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    Cfile_Destruct},
        {Oj_Close_OjMID,       Cfile_Close},
        {Oj_Read_OjMID,        Cfile_Read},
        {Oj_Write_OjMID,       Cfile_Write},
        {Oj_Read_Line_OjMID,   Cfile_Read_Line},
        {Oj_Write_Line_OjMID,  Cfile_Write_Line},
        {Oj_Read_All_OjMID,    Cfile_Read_All},
        {Oj_Seek_OjMID,        Cfile_Seek},
        {Oj_Tell_OjMID,        Cfile_Tell},
        {Oj_Length_OjMID,      Cfile_Length},
        {Oj_Available_OjMID,   Cfile_Available},
        {Oj_Eof_OjMID,         Cfile_Eof},
        {Oj_Flush_OjMID,       Cfile_Flush},
        {0}};
    YO_CFILE *f = Yo_Object(sizeof(YO_CFILE),funcs);
    f->fd = fd;
    f->shared = share;
    f->name = name?Str_Copy_Npl(name,-1):__yoTa("<file>",0);
    return f;
  }
#endif
  ;

YO_CFILE *Pfile_Object(FILE *fd, char *cmd, int share)
#ifdef _YO_FILE_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    Pfile_Destruct},
        {Oj_Close_OjMID,       Pfile_Close},
        {Oj_Read_OjMID,        Cfile_Read},
        {Oj_Write_OjMID,       Cfile_Write},
        {Oj_Read_Line_OjMID,   Cfile_Read_Line},
        {Oj_Write_Line_OjMID,  Cfile_Write_Line},
        {Oj_Eof_OjMID,         Cfile_Eof},
        {Oj_Flush_OjMID,       Cfile_Flush},
        {0}};
    YO_CFILE *f = Yo_Object(sizeof(YO_CFILE),funcs);
    f->fd = fd;
    f->shared = share;
    f->name = cmd?Str_Copy_Npl(cmd,-1):__yoTa("<command>",0);
    return f;
  }
#endif
  ;

enum _YO_FILE_ACCESS_FLAGS
  {
    YO_FILE_READ        = 1,
    YO_FILE_WRITE       = 2,
    YO_FILE_READWRITE   = YO_FILE_READ|YO_FILE_WRITE,
    YO_FILE_FORWARD     = 32,
    YO_FILE_TEXT        = 64, // by default is binary mode
    YO_FILE_CREATE_PATH = 128, // create expected path if doesn't exists
    YO_FILE_APPEND      = 256,
    
    //_YO_FILE_NEED_EXITENT_FILE = 0x080000,
    YO_FILE_OPENEXISTS  = 0x000000, // open if exists
    YO_FILE_CREATENEW   = 0x010000, // error if exists
    YO_FILE_OPENALWAYS  = 0x020000, // if not exists create new
    YO_FILE_CREATEALWAYS= 0x030000, // if exists unlink and create new
    YO_FILE_OVERWRITE   = 0x040000, // if exists truncate
    YO_FILE_CREATE_MASK = 0x0f0000,
    
    YO_FILE_CREATE      = YO_FILE_READWRITE|YO_FILE_CREATE_PATH|YO_FILE_CREATEALWAYS,
    YO_FILE_REUSE       = YO_FILE_READWRITE|YO_FILE_OPENALWAYS,
    YO_FILE_CONSTANT    = YO_FILE_READ|YO_FILE_OPENEXISTS,
    YO_FILE_MODIFY      = YO_FILE_READWRITE|YO_FILE_OPENEXISTS, 
  };

void File_Check_Access_Is_Satisfied(char *path, uint_t access)
#ifdef _YO_FILE_BUILTIN
  {
    YO_FILE_STATS st = {0};
    File_Get_Stats(path,&st,1);
    
    if ( (access & YO_FILE_CREATE_PATH) && !st.f.exists )
      Create_Required_Dirs(path);
    
    if ( st.f.exists )
      if (st.f.is_directory )
        __Raise_Format(YO_ERROR_IO,("file '%s' is directory",path));
      else if ( (access & YO_FILE_CREATE_MASK) == YO_FILE_CREATENEW  )
        __Raise_Format(YO_ERROR_IO,("file '%s' already exists",path));
      else if ( (access & YO_FILE_CREATE_MASK) == YO_FILE_CREATEALWAYS )
        File_Unlink(path,0);
      else;
    else if ( (access & YO_FILE_CREATE_MASK) == YO_FILE_OPENEXISTS )
      __Raise_Format(YO_ERROR_DOESNT_EXIST,("file '%s' does not exist",path));
  }
#endif
  ;

uint_t File_Access_From_Str(char *S)
#ifdef _YO_FILE_BUILTIN
  {
    uint_t access = 0;
    for ( ;*S; ++S )
      switch (*S)
        {
          case '+': access |= YO_FILE_WRITE; /*falldown*/
          case 'r': access |= YO_FILE_READ; break;
          case 'a': access |= 
            YO_FILE_WRITE
            |YO_FILE_APPEND
            |YO_FILE_FORWARD
            |YO_FILE_OPENALWAYS;
          case 'w': access |= YO_FILE_WRITE|YO_FILE_OVERWRITE; break;
          case 'c': access |= YO_FILE_WRITE|YO_FILE_CREATEALWAYS; break;
          case 'n': access |= YO_FILE_WRITE|YO_FILE_CREATENEW; break;
          case 't': access |= YO_FILE_TEXT; break;
          case 'P': access |= YO_FILE_CREATE_PATH; break;
          default: break;
        }
    return access;
  }
#endif
  ;

#define File_Open(Name,Access) Cfile_Open(Name,Access)

void Cfile_Remove_Nonstandard_AC(char *nonst, char *ac)
#ifdef _YO_FILE_BUILTIN
  {
    int ac_r = 0;
    int ac_w = 0;
    int ac_plus = 0;
    int ac_t = 0;
/*  int ac_a = 0;
    int ac_b = 0; */

    else *ac++ = 'b';    
    *ac = 0;
  }
#endif
  ;

void *Cfile_Open_Raw(char *name, char *access)
#ifdef _YO_FILE_BUILTIN
  {
    char ac[9];
    void *f = 0;
    
    // always binary mode if 't' not declared manualy
    Cfile_Remove_Nonstandard_AC(access,ac);
    
    #ifdef __windoze
      if ( 0 != (f = _wfopen(Str_Utf8_To_Unicode(name),Str_Utf8_To_Unicode(ac))) )
    #else
      if ( 0 != (f = fopen(name,ac)) )
    #endif
        f = Cfile_Object(f,name,0);
        
    return f;
  }
#endif
  ;

void *Pfile_Open(char *command, char *access)
#ifdef _YO_FILE_BUILTIN
  {
    void *f = 0;
    #ifdef __windoze
      int text = 0, i;
      wchar_t ac[9] = {0};
      for ( i = 0; access[i] && i < sizeof(ac)-1; ++i )
        {

        f = Pfile_Object(f,command,0);
    return f;
  }
#endif
  ;

void *Cfile_Open(char *name, char *access)
#ifdef _YO_FILE_BUILTIN
  {
    void *f = 0;
    __Auto_Ptr(f)
      {
        File_Check_Access_Is_Satisfied(name,File_Access_From_Str(access));
        f = Cfile_Open_Raw(name,access);
        if ( !f )
          File_Check_Error("open file",0,name,1);
      }
    return f;
  }
#endif
  ;

#define Cfile_Acquire(Name,Fd) Cfile_Object(Fd,Name,0)
#define Cfile_Share(Name,Fd)   Cfile_Object(Fd,Name,1)

void *Cfile_Temp()
#ifdef _YO_FILE_BUILTIN
  {
    FILE *f = tmpfile();
    if ( !f )
      File_Check_Error("open file",0,"tmpfile",1);
    return Cfile_Object(f,"tmpfile",0);
  }
#endif
  ;

int Oj_Write_BOM(void *f,int bom)
#ifdef _YO_FILE_BUILTIN
  {
    switch( bom )
      {
        case YO_BOM_DOESNT_PRESENT:
          return 0; // none
        case YO_BOM_UTF16_LE:
          return Oj_Write(f,"\xff\xfe",2,2);
        case YO_BOM_UTF16_BE:
          return Oj_Write(f,"\xfe\xff",2,2);
        case YO_BOM_UTF8:
          return Oj_Write(f,"\xef\xbb\xbf",3,3);
        default:
          __Raise(YO_ERROR_INVALID_PARAM,__yoTa("bad BOM identifier",0));
      }
      
    return 0; /*fake*/
  }
#endif
  ;

#define __Pfd_Lock(Pfd) __Interlock_Opt( (void)0, Pfd, __Pfd_Lock_In, __Pfd_Lock_Out, __Pfd_Lock_Out )

#ifdef __windoze

#define   LOCK_SH   1    /* shared lock */
#define   LOCK_EX   2    /* exclusive lock */
#define   LOCK_NB   4    /* don't block when locking */
#define   LOCK_UN   8    /* unlock */

int flock(int fd, int opt)
#ifdef _YO_FILE_BUILTIN
  {
    return 0;
  }
#endif
  ;

#endif /* __windoze */

void __Pfd_Lock_In(int *pfd) 
#ifdef _YO_FILE_BUILTIN
  {
    STRICT_REQUIRE(pfd);
    
    if ( flock(*pfd,LOCK_EX) )
      __Raise_Format(YO_ERROR_IO,("failed to lock fd %d: %s",*pfd,strerror(errno)));
  }
#endif
  ;

void __Pfd_Lock_Out(int *pfd) 
#ifdef _YO_FILE_BUILTIN
  {
    STRICT_REQUIRE(pfd);
    
    if ( flock(*pfd,LOCK_UN) )
      if ( errno != EBADF )
        __Fatal("failed to unlock file");
  }
#endif
  ;

#define __Pfd_Guard(Pfd) __Interlock_Opt( (void)0, Pfd, (void), __Pfd_Guard_Out, __Pfd_Guard_Out )
void __Pfd_Guard_Out(int *pfd) 
#ifdef _YO_FILE_BUILTIN
  {
    STRICT_REQUIRE(pfd);
    
    if ( *pfd >= 0 )
      {
        close(*pfd);
        *pfd = -1;
      }
  }
#endif
  ;

int Oj_Copy_File(void *src, void *dst)
#ifdef _YO_FILE_BUILTIN
  {
    char bf[YO_FILE_COPY_BUFFER_SIZE];
    int count = 0;
    int (*xread)(void*,void*,int,int) = Yo_Find_Method_Of(&src,Oj_Read_OjMID,YO_RAISE_ERROR);
    int (*xwrite)(void*,void*,int,int) = Yo_Find_Method_Of(&dst,Oj_Write_OjMID,YO_RAISE_ERROR);
    for ( ;; )
      {
        int i = xread(src,bf,YO_FILE_COPY_BUFFER_SIZE,0);
        if ( !i ) break;
        xwrite(dst,bf,i,i);
        count += i;
      }
    return count;
  }
#endif
  ;

#define Write_Out(Fd,Data,Count) Fd_Write_Out(Fd,Data,Count,0)
#define Write_Out_Raise(Fd,Data,Count) Fd_Write_Out(Fd,Data,Count,1)
int Fd_Write_Out(int fd, void *data, int count, int do_raise) 
#ifdef _YO_FILE_BUILTIN
  {
    int i;
    
    for ( i = 0; i < count;  )
      {
        int r = write(fd,(char*)data+i,count-i);
        if ( r >= 0 )
          i += r;
        else if ( errno != EAGAIN )
          {
            int err = errno;
            if ( do_raise )
              __Raise_Format(YO_ERROR_IO,(__yoTa("failed to write file: %s",0),strerror(err)));
            return err;
          }
      }
      
    return 0;
  }
#endif
  ;

#define Read_Into(Fd,Data,Count) Fd_Read_Into(Fd,Data,Count,0)
#define Read_Into_Raise(Fd,Data,Count) Fd_Read_Into(Fd,Data,Count,1)
int Fd_Read_Into(int fd, void *data, int count, int do_raise) 
#ifdef _YO_FILE_BUILTIN
  {
    int i;
    
    for ( i = 0; i < count;  )
      {
        int r = read(fd,(char*)data+i,count-i);
        if ( r > 0 )
          i += r;
        else if ( !r )
          {
            if ( do_raise )
              __Raise_Format(YO_ERROR_IO,(__yoTa("failed to read file: %s",0),"eof"));
            return -1;
          }
        else if ( errno != EAGAIN )
          {
            int err = errno;
            if ( do_raise )
              __Raise_Format(YO_ERROR_IO,(__yoTa("failed to read file: %s",0),strerror(err)));
            return err;
          }
      }
      
    return 0;
  }
#endif
  ;

#define Lseek(Fd,Pos) Fd_Lseek(Fd,Pos,0)
#define Lseek_Raise(Fd,Pos) Fd_Lseek(Fd,Pos,1)
int Fd_Lseek(int fd, quad_t pos, int do_raise)
#ifdef _YO_FILE_BUILTIN
  {
    if ( 0 >  
  #ifdef _FILEi32
    lseek(fd,(long)pos,(pos<0?SEEK_END:SEEK_SET))
  #else
    _WINPOSIX(_lseeki64,lseek64)(fd,pos,(pos<0?SEEK_END:SEEK_SET))
  #endif
    )
      {
        int err = errno;
        if ( do_raise )
          __Raise_Format(YO_ERROR_IO,(__yoTa("failed to seek file: %s",0),strerror(err)));
        return err;
      }
    return 0;
  }
#endif
  ;

#define Open_File(Name,Opt) Fd_Open_File(Name,Opt,0600,0)
#define Open_File_Raise(Name,Opt) Fd_Open_File(Name,Opt,0600,1)
int Fd_Open_File(char *name, int opt, int secu, int do_raise)
#ifdef _YO_FILE_BUILTIN
  {
    int fd;
    #ifdef __windoze
      if ( !(opt & _O_TEXT) ) opt |= _O_BINARY;
      fd = _wopen(Str_Utf8_To_Unicode(name),opt,secu);
    #else
      fd = open(name,opt,secu);
    #endif
    if ( fd < 0 )
      {
        int err = errno;
        if ( do_raise )
          __Raise_Format(YO_ERROR_IO,(__yoTa("failed to open file '%s': %s",0),name,strerror(err)));
        return -err;
      }
    return fd;
  }
#endif
  ;
  
void File_Move(char *old_name, char *new_name)
#ifdef _YO_FILE_BUILTIN
  {
    int err = 0;
  #ifdef __windoze
    wchar_t *So = Str_Utf8_To_Unicode(old_name);
    wchar_t *Sn = Str_Utf8_To_Unicode(new_name);
    err = _wrename(So,Sn);
    Yo_Release(Sn);

      {
        File_Check_Error("rename",0,old_name,1); 
      }
  }
#endif
  ;

typedef struct _YO_BUFFER_FILE
  {
    YO_BUFFER *bf;
    int offs;
  } YO_BUFFER_FILE;

void YO_BUFFER_FILE_Destruct(YO_BUFFER_FILE *file)
#ifdef _YO_FILE_BUILTIN
  {
    __Unrefe(file->bf);
    __Destruct(file);
  }
#endif
  ;

int Buffer_File_Close(YO_BUFFER_FILE *file)
#ifdef _YO_FILE_BUILTIN
  {
    return 0;
  }
#endif
  ;

int Buffer_File_Read(YO_BUFFER_FILE *f, void *buf, int count, int min_count)
#ifdef _YO_FILE_BUILTIN
  {
    if ( min_count < 0 ) min_count = count;
    if ( f->offs + min_count > f->bf->count )
      __Raise(YO_ERROR_IO_EOF,"end of file");
    count = Yo_MIN(f->bf->count-f->offs,count);
    memcpy(buf,f->bf->at+f->offs,count);
    f->offs += count;
    return count;
  }
#endif
  ;

int Buffer_File_Write(YO_BUFFER_FILE *f, void *buf, int count, int min_count)
#ifdef _YO_FILE_BUILTIN
  {
    if (f->bf->count < f->offs + count )
      Buffer_Resize(f->bf,f->offs + count);
    memcpy(f->bf->at+f->offs,buf,count);
    f->offs += count;
    return count;
  }
#endif
  ;

quad_t Buffer_File_Length(YO_BUFFER_FILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    return f->bf->count;
  }
#endif
  ;

quad_t Buffer_File_Available(YO_BUFFER_FILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( f->offs >= f->bf->count )
      return 0;
    return f->bf->count - f->offs;
  }
#endif
  ;

int Buffer_File_Eof(YO_BUFFER_FILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    if ( f->offs >= f->bf->count )
      return 1;
    return 0;
  }
#endif
  ;

quad_t Buffer_File_Seek(YO_BUFFER_FILE *f, quad_t pos, int whence)
#ifdef _YO_FILE_BUILTIN
  {
    quad_t old = f->offs;
    if ( whence == SEEK_SET )
      f->offs = (int)pos;
    else if ( whence == SEEK_CUR )
      f->offs += (int)pos;
    else if ( whence == SEEK_END )
      f->offs = f->bf->count + (int)pos;
    if ( f->offs < 0 ) 
      {
        f->offs = 0;
        __Raise(YO_ERROR_IO,"negative file offset");
      }
    return old;
  }
#endif
  ;
  
quad_t Buffer_File_Tell(YO_BUFFER_FILE *f)
#ifdef _YO_FILE_BUILTIN
  {
    return f->offs;
  }
#endif
  ;

void Buffer_File_Flush()
#ifdef _YO_FILE_BUILTIN
  {
  }
#endif
  ;

void *Buffer_As_File(YO_BUFFER *bf)
#ifdef _YO_FILE_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    YO_BUFFER_FILE_Destruct},
        {Oj_Close_OjMID,       Buffer_File_Close},
        {Oj_Read_OjMID,        Buffer_File_Read},
        {Oj_Write_OjMID,       Buffer_File_Write},
        {Oj_Available_OjMID,   Buffer_File_Available},
        {Oj_Eof_OjMID,         Buffer_File_Eof},
        {Oj_Length_OjMID,      Buffer_File_Length},
        {Oj_Seek_OjMID,        Buffer_File_Seek},
        {Oj_Tell_OjMID,        Buffer_File_Tell},
        {Oj_Flush_OjMID,       Buffer_File_Flush},
        {0}
      };
    YO_BUFFER_FILE *file = __Object(sizeof(YO_BUFFER_FILE),funcs);
    file->bf = __Refe(bf);
    return file;
  }
#endif
  ;

void YO_MEMORY_FILE_Destruct(YO_BUFFER_FILE *file)
#ifdef _YO_FILE_BUILTIN
  {
    free(file->bf);
    __Destruct(file);
  }
#endif
  ;

int Memory_File_Write(YO_BUFFER_FILE *f, void *buf, int count, int min_count)
#ifdef _YO_FILE_BUILTIN
  {
    if (f->bf->count < f->offs + count )
      __Raise(YO_ERROR_OUT_OF_RANGE,"out of memory range");
    memcpy(f->bf->at+f->offs,buf,count);
    f->offs += count;
    return count;
  }
#endif
  ;

void *Memory_As_File(void *mem, int mem_len)
#ifdef _YO_FILE_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Destruct_OjMID,    YO_MEMORY_FILE_Destruct},
        {Oj_Close_OjMID,       Buffer_File_Close},
        {Oj_Read_OjMID,        Buffer_File_Read},
        {Oj_Write_OjMID,       Memory_File_Write},
        {Oj_Available_OjMID,   Buffer_File_Available},
        {Oj_Eof_OjMID,         Buffer_File_Eof},
        {Oj_Length_OjMID,      Buffer_File_Length},
        {Oj_Seek_OjMID,        Buffer_File_Seek},
        {Oj_Tell_OjMID,        Buffer_File_Tell},
        {Oj_Flush_OjMID,       Buffer_File_Flush},
        {0}
      };
      
    YO_BUFFER_FILE *file = __Object(sizeof(YO_BUFFER_FILE),funcs);
    file->bf = __Zero_Malloc_Npl(sizeof(YO_BUFFER));
    file->bf->at = mem;
    file->bf->count = mem_len;
    return file;
  }
#endif
  ;

void Oj_Print(void *foj, char *S)
#ifdef _YO_FILE_BUILTIN
  {
    int S_len = S?strlen(S):0;
    if ( S_len )
      Oj_Write_Full(foj,S,S_len);
  }
#endif
  ;

void Oj_Printf(void *foj, char *fmt, ...)
#ifdef _YO_FILE_BUILTIN
  {
    __Auto_Release
      {
        va_list va;
        char *text;
        va_start(va,fmt);
        text = __Pool(Yo_Format_(fmt,va));
        va_end(va);
        Oj_Print(foj,text);
      }
  }
#endif
  ;

void Oj_Fill(void *fobj, byte_t val, int count)
#ifdef _YO_FILE_BUILTIN
  {
    byte_t bf[512];
    
    REQUIRE(count >= 0);
    memset(bf,val,sizeof(bf));
    while ( count > 0 )
      {
        int L = Yo_MIN(count,sizeof(bf));
        Oj_Write_Full(fobj,bf,L);
        count -= L;
      }
  }
#endif
  ;

int Oj_Apply_File(void *foj, void *accu, void (*algo)(void *accu,void *buf, int L))
#ifdef _YO_FILE_BUILTIN
  {
    char bf[YO_FILE_COPY_BUFFER_SIZE];
    int count = 0;
    int (*xread)(void*,void*,int,int) = Yo_Find_Method_Of(&foj,Oj_Read_OjMID,YO_RAISE_ERROR);
    for ( ;; )
      {
        int i = xread(foj,bf,YO_FILE_COPY_BUFFER_SIZE,0);
        if ( !i ) break;
        algo(accu,bf,i);
        count += i;
      }
    return count;
  }
#endif
  ;

_YO_FILE_EXTERN char Oj_Digest_File_Update_OjMID[] _YO_FILE_BUILTIN_CODE( = "digest-file-update/@*"); 
void Oj_Digest_File_Update(void *dgst,void *foj) _YO_FILE_BUILTIN_CODE(
  { void(*update)(void*,void*,int) = Yo_Find_Method_Of(&dgst,Oj_Digest_Update_OjMID,YO_RAISE_ERROR);
    Oj_Apply_File(foj,dgst,update); });

void File_Update_Digest(void *dgst, char *filename)
#ifdef _YO_FILE_BUILTIN
  {
    __Auto_Release Oj_Digest_File_Update(dgst,Cfile_Open(filename,"r"));
  }
#endif
  ;

#endif /* C_once_E9479D04_5D69_4A1A_944F_0C99A852DC0B */

#include "buffer.hc"
#include "dicto.hc"
#include "file.hc"
#include "tcpip.hc"
#include "url.hc"

#ifdef _LIBYOYO
#define _YO_HTTPD_BUILTIN
#endif

struct _YO_HTTPD_REQUEST;
typedef int (*httpd_callback_t)(void *obj, struct _YO_HTTPD_REQUEST *rqst, int status);
typedef struct _YO_HTTPD
  {
    YO_TCPSOK *sok;
    char *host;
    int port;

    struct _YO_HTTPD_REQUEST *rqst;
    httpd_callback_t callback;
    void *obj;
  } YO_HTTPD;

typedef struct _YO_HTTPD_REQUEST
  {
    YO_BUFFER *bf; /* associated with instrm when post data is small */
    
    /* request */    
    void *instrm;
    char *instrm_type; /*handle by qhdr*/
    int   instrm_length;
    YO_DICTO  *qhdr;
    
    char *uri;
    char *referer;
    char *remote_addr;
    int   remote_port;
    int   method;
    int   httpver;
        
    /* response */
    void *outstrm;
    char *outstrm_type;
    char *outstrm_charset;
    int   outstrm_length;
    
    YO_ARRAY *hlns;
    YO_ARRAY *cookie;
    char *location;
    char *cache_control;
  
    /* internal */    
    YO_TCPSOK *sok;
    YO_HTTPD  *httpd;
    int nline;
    int left;
    struct _YO_HTTPD_REQUEST *next;
    
    void (*on_detach)(struct _YO_HTTPD_REQUEST *);
  } YO_HTTPD_REQUEST;

void Httpd_Detach_Request(YO_HTTPD_REQUEST *rqst)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_HTTPD *httpd = rqst->httpd;
    YO_HTTPD_REQUEST **q = &httpd->rqst;
    
    if ( rqst->on_detach )
      rqst->on_detach(rqst);
    
    while ( *q )
      {
        if ( *q == rqst )
          {
            *q = rqst->next;
            rqst->next = 0;
            break;
          }
        q = &(*q)->next;
      }
  }
#endif
  ;
  
void YO_HTTPD_REQUEST_Destruct(YO_HTTPD_REQUEST *rqst)
#ifdef _YO_HTTPD_BUILTIN
  {
    Httpd_Detach_Request(rqst);
    __Unrefe(rqst->httpd);
    __Unrefe(rqst->sok);
    free(rqst->remote_addr);
    free(rqst->uri);
    free(rqst->referer);

    HTTPD_PUT_METHOD       = 1003,
    HTTPD_HEAD_METHOD      = 1004,
    HTTPD_DELETE_METHOD    = 1005,

  };

char *Httpd_Method_String(int method)
#ifdef _YO_HTTPD_BUILTIN
  {
    switch(method)
      {
        case HTTPD_GET_METHOD:    return "GET";
        case HTTPD_POST_METHOD:   return "POST";
        case HTTPD_PUT_METHOD:    return "PUT";
        case HTTPD_HEAD_METHOD:   return "HEAD";
        case HTTPD_DELETE_METHOD: return "DELETE";
      }
      
    return "NONE";
  }
#endif
  ;

YO_HTTPD_REQUEST *Httpd_Request(YO_HTTPD *httpd, YO_TCPSOK *sok)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_HTTPD_REQUEST *rqst = __Object_Dtor(sizeof(YO_HTTPD_REQUEST),YO_HTTPD_REQUEST_Destruct);
    rqst->httpd = __Refe(httpd);
    rqst->sok = __Refe(sok);
    rqst->remote_addr = Ipv4_Format_Npl(sok->ip);
    rqst->remote_port = sok->port;
    rqst->next = httpd->rqst;
    httpd->rqst = rqst;
    rqst->bf = __Refe(Buffer_Init(0));
    rqst->qhdr = __Refe(Dicto_Ptrs());
    rqst->cookie = __Refe(Array_Pchars());
    rqst->hlns = __Refe(Array_Pchars());
    Buffer_Reserve(rqst->bf,HTTPD_MAXBUF_LENGTH);
    return rqst;
  }
#endif
  ;
  
int Httpd_Rqst_Range(YO_HTTPD_REQUEST *rqst, int *rng_pos, int *rng_len)
#ifdef _YO_HTTPD_BUILTIN
  {
    char *foo = Dicto_Get(rqst->qhdr,"RANGE",0);
    
    if ( foo )
      {
        int start = 0, end = 0;
        if ( sscanf(foo,"bytes=%u-%u",&start,&end) == 2 )
          if ( start >= 0 && end >= start )
            {
              *rng_pos = start;
              *rng_len = end-start+1;
              return 1;
            }
      }
      
    return 0;
  }
#endif
  ;
  
void Httpd_Set_Content_Range(YO_HTTPD_REQUEST *rqst, int rng_pos, int rng_len, int total)
#ifdef _YO_HTTPD_BUILTIN
  {
    Array_Push(rqst->hlns,
              __Format_Npl("Content-Range: bytes %d-%d/%d",rng_pos,rng_len+rng_pos-1,total));
  }
#endif
  ;
  
char *Httpd_Status_Text(int st)
#ifdef _YO_HTTPD_BUILTIN
  {
    switch ( st )
      {
        case 200: return "OK";
        case 201: return "Created";
        case 202: return "Accepted";
        case 203: return "Non-Authoritative Information";

        default:  
          return "Unknown Status"; 
      }
  }
#endif
  ;
  
void Httpd_Gen_Response(YO_HTTPD_REQUEST *rqst, int st)
#ifdef _YO_HTTPD_BUILTIN
  {
    int i;
    YO_BUFFER *bf = rqst->bf;
    bf->count = 0;
    Buffer_Printf(bf,"HTTP/1.1 %d %s\r\n",st,Httpd_Status_Text(st));
    Buffer_Append(bf,"Connection: close\r\n",-1);
    if ( rqst->location )
      {
        Buffer_Printf(bf,"Location: %s\r\n",rqst->location);
      }

            bf->count += L;
          }
      }
  }  
#endif
  ;
  
void Cbk_Httpd_Sending_Result(YO_HTTPD_REQUEST *rqst, int error)
#ifdef _YO_HTTPD_BUILTIN
  {
    int L;
    YO_BUFFER *bf = rqst->bf;

    if ( error )
      {
        rqst->httpd->callback(rqst->httpd->obj,rqst,HTTPD_STAT_IOFAIL);
        Tcp_Close(rqst->sok);
        return;
      }

  finished:
    rqst->httpd->callback(rqst->httpd->obj,rqst,HTTPD_STAT_FINISHED);
    Tcp_Graceful_Close(rqst->sok);
  }
#endif
  ;
  
void Httpd_Continue_Request(YO_HTTPD_REQUEST *rqst, int st)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_BUFFER *bf = rqst->bf;
    Httpd_Gen_Response(rqst,st);
    Tcp_Aio_Send(rqst->sok,bf->at,bf->count,Cbk_Httpd_Sending_Result,rqst);
  }
#endif
  ;
  
void Httpd_Perform_Request(YO_HTTPD_REQUEST *rqst)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_BUFFER *bf = rqst->bf;
    int st;
    
    if ( rqst->method == HTTPD_POST_METHOD || rqst->method == HTTPD_PUT_METHOD )
      {
        if ( !rqst->instrm ) 
          {
            rqst->instrm_length = bf->count;
            rqst->instrm = __Refe(Buffer_As_File(bf));
          }
        Oj_Seek(rqst->instrm,0,0);
      }
      
    st = rqst->httpd->callback(rqst->httpd->obj,rqst,HTTPD_RQST_PERFORM);
    if ( st )
      Httpd_Continue_Request(rqst,st);
  }
#endif
  ;
    
void Cbk_Httpd_Getting_Postdta(YO_HTTPD_REQUEST *rqst, int error, int count)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_BUFFER *bf = rqst->bf;
    
    if ( error )
      {
        rqst->httpd->callback(rqst->httpd->obj,rqst,HTTPD_STAT_IOFAIL);
        Tcp_Close(rqst->sok);
        return;
      }

      {
        Httpd_Perform_Request(rqst);
      }  
  }
#endif
  ;
  
void Httpd_Analyze_Qline(char *text,YO_HTTPD_REQUEST *rqst)
#ifdef _YO_HTTPD_BUILTIN
  {
    char *S, *q;
    
    S = text;
    while ( *S && *S != '\n' && Isspace(*S) ) ++S;
    q = S;
    while ( *q && !Isspace(*q) ) ++q;

    
    if ( !strncmp_I(S,"HTTP/1.",7) )
      rqst->httpver = strtol(S+7,0,10);
  }
#endif
  ;
  
void Httpd_Analyze_Headers(char *text,YO_DICTO *dct)
#ifdef _YO_HTTPD_BUILTIN
  {
    int i;
    char *q, *Q, *S = text;
    while (*S!='\n') ++S; /* skip HTTP/1.x query line */
    q = ++S;
    for (;;)
      {

          }
        S = ++q;
      }
  }
#endif
  ;

void Cbk_Httpd_Getting_Request(YO_HTTPD_REQUEST *rqst, int error, int count)
#ifdef _YO_HTTPD_BUILTIN
  {
    int i;
    YO_BUFFER *bf = rqst->bf;

    if ( error )
      {
        rqst->httpd->callback(rqst->httpd->obj,rqst,HTTPD_STAT_IOFAIL);
        Tcp_Close(rqst->sok);
        return;
      }

              }
          }
      }
  }
#endif
  ;
  
void Cbk_Httpd_Accept(YO_HTTPD *httpd,int error,YO_TCPSOK *sok)
#ifdef _YO_HTTPD_BUILTIN
  {
    if ( error )
      {
        httpd->callback(httpd->obj,0,HTTPD_STAT_ACCEPTFAIL);
        return;
      }
    else
      {
        YO_HTTPD_REQUEST *rqst;
        Tcp_Aio_Accept(httpd->sok,Cbk_Httpd_Accept,httpd);
        rqst = Httpd_Request(httpd,sok);
        if ( HTTPD_ACCEPT == httpd->callback(httpd->obj,rqst,HTTPD_RQST_CONNECT) )
          Tcp_Aio_Recv(rqst->sok,rqst->bf->at,rqst->bf->capacity,1,Cbk_Httpd_Getting_Request,rqst);
        else
          httpd->callback(httpd->obj,rqst,HTTPD_STAT_REJECTED);
      }
  }
#endif
  ;
  
void Httpd_Listen(YO_HTTPD *httpd, char *host, int port)
#ifdef _YO_HTTPD_BUILTIN
  {
    httpd->sok = __Refe(Tcp_Listen(host,port,0));
    free(httpd->host);
    httpd->host = Str_Copy_Npl(host,-1);
    httpd->port = port;
    Tcp_Aio_Accept(httpd->sok,Cbk_Httpd_Accept,httpd);
  }
#endif
  ;
  
void Httpd_Shutdown(YO_HTTPD *httpd)
#ifdef _YO_HTTPD_BUILTIN
  {
    Tcp_Shutdown(httpd->sok);
  }
#endif
  ;
  
void YO_HTTPD_Destruct(YO_HTTPD *httpd)
#ifdef _YO_HTTPD_BUILTIN
  {
    STRICT_REQUIRE(httpd->rqst == 0);
    free(httpd->host);
    __Unrefe(httpd->obj);
    __Unrefe(httpd->sok);
    __Destruct(httpd);
  }
#endif
  ;
  
YO_HTTPD *Httpd_Server(httpd_callback_t callback,void *obj)
#ifdef _YO_HTTPD_BUILTIN
  {
    YO_HTTPD *httpd = __Object_Dtor(sizeof(YO_HTTPD),YO_HTTPD_Destruct);
    httpd->obj  = __Refe(obj);
    httpd->callback = callback;
    return httpd;
  }
#endif
  ;
  
#endif /* C_once_BE85262D_CDA8_4AF5_B684_8A30EB6D7370 */

#include "url.hc"
#include "tasque.hc"

#ifdef _LIBYOYO
#define _HTTPX_BUILTIN
#endif

typedef void (*httpx_collback_t)(void *obj, struct _YO_HTTPX *httpx, int status);

typedef struct _YO_HTTPX
  {
    void *netchnl;
    YO_URL *url;
    YO_URL *proxy_url;
    
    int  method;
    int  maxcount;
    int  left;
    
    void *outstrm;
    void *poststrm;
    void *mon_obj;
    httpx_collback_t mon_callback;

    int nline;
    YO_BUFFER *bf;
    
    YO_DICTO  *hdrs;
    YO_BUFFER *content;
    int   state;
    int   streamed;
    int   status;
    char *status_text;
    
    int async:      1;
    int keepalive:  1;
    int legacy10:   1;
    int ssl:        1;
    int proxy:      1;
    int interrupted:1;
    int chunked:    1;
        
  } YO_HTTPX;

void YO_HTTPX_Destruct(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    __Unrefe(httpx->netchnl);
    __Unrefe(httpx->url);
    __Unrefe(httpx->proxy_url);
    __Unrefe(httpx->outstrm);
    __Unrefe(httpx->poststrm);

    HTTPX_INVALID_RESPONSE        = 0x00000d01,
    HTTPX_INVALID_RESPONSE_CODE   = 0x00000d02,
  };

#define HTTPX_SUCCEEDED(Status) (((Status)&0x8f000000) == 0)
#define HTTPX_STATUS(Status)    ((Status)&0x0fff)

void Httpx_Aio_Recv(YO_HTTPX *httpx, void *dta, int count, int mincount, tcp_recv_callback_t callback)
#ifdef _HTTPX_BUILTIN
  {
    if ( !httpx->ssl )
      Tcp_Aio_Recv(httpx->netchnl,dta,count,mincount,callback,httpx);
  }
#endif
  ;
  
void Httpx_Aio_Send(YO_HTTPX *httpx, void *dta, int count, tcp_send_callback_t callback)
#ifdef _HTTPX_BUILTIN
  {
    if ( !httpx->ssl )
      Tcp_Aio_Send(httpx->netchnl,dta,count,callback,httpx);
  }
#endif
  ;
  
void Httpx_Append_Header_Line(YO_BUFFER *bf, char *name, char *value)
#ifdef _HTTPX_BUILTIN
  {
    Buffer_Append(bf,name,-1);
    Buffer_Append(bf,": ",2);
    Buffer_Append(bf,value,-1);
    Buffer_Append(bf,"\r\n",2);
  }

      return;
      
    Httpx_Append_Header_Line(bf,name,value); 
  }
#endif  
  ;
  
void Httpx_Append_Common_Header_Line(YO_BUFFER *bf, YO_DICTO *hdrs,char *name, char *dflt)
#ifdef _HTTPX_BUILTIN
  {
    char *val = hdrs?Dicto_Get(hdrs,name,dflt):dflt;
    Httpx_Append_Header_Line(bf,name,val); 
  }
#endif
  ;
    
void Httpx_Append_Request_Line(YO_BUFFER *bf, int method, char *uri, int http10)
#ifdef _HTTPX_BUILTIN
  {
    static char s_GET[3]  = "GET";
    static char s_PUT[3]  = "PUT";
    static char s_POST[4] = "POST";
    static char s_HEAD[4] = "HEAD";
    
    switch ( method )
      {
        case HTTPX_GET:  Buffer_Append(bf,s_GET,sizeof(s_GET)); break;
        case HTTPX_PUT:  Buffer_Append(bf,s_PUT,sizeof(s_PUT)); break;
        case HTTPX_POST: Buffer_Append(bf,s_POST,sizeof(s_POST)); break;
        case HTTPX_HEAD: Buffer_Append(bf,s_HEAD,sizeof(s_HEAD)); break;
        default:
          __Raise_Format(YO_ERROR_ILLFORMED,(__yoTa("invalid HTTPX request method: %d",0),method));
      }
      
    Buffer_Append(bf," ",1);
    Buffer_Append(bf,uri,-1);
    
    if ( http10 )
      Buffer_Append(bf," HTTP/1.0\r\n",11);
    else
      Buffer_Append(bf," HTTP/1.1\r\n",11);
  }
#endif
  ;
  
void Build_Http_Request(YO_HTTPX *httpx, int method, char *uri, YO_DICTO *hdrs)
#ifdef _HTTPX_BUILTIN
  {
    YO_BUFFER *bf = httpx->bf;
    bf->count = 0;
    Httpx_Append_Request_Line(bf,method,uri,httpx->legacy10);
    Httpx_Append_Common_Header_Line(bf,hdrs,"Host",httpx->url->host);
    Httpx_Append_Common_Header_Line(bf,hdrs,"User-Agent","httpx");
    Httpx_Append_Common_Header_Line(bf,hdrs,"Accept","*/*");
    Httpx_Append_Common_Header_Line(bf,hdrs,"Accept-Charset","utf-8");
    if ( httpx->keepalive )

        Httpx_Append_Header_Line(bf,"Content-Length",len);
      }
    Buffer_Append(bf,"\r\n",2);      
  }
#endif
  ;

void Httpx_Interrupt(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    httpx->interrupted = 1;
    if ( !httpx->ssl )
      Tcp_Close(httpx->netchnl);
  }
#endif
  ;
    
void Httpx_Do_Callback(YO_HTTPX *httpx, int status)
#ifdef _HTTPX_BUILTIN
  {
    if ( httpx->mon_callback )
      httpx->mon_callback(httpx->mon_obj,httpx,httpx->state|status);

    if ( ( httpx->interrupted || !HTTPX_SUCCEEDED(status) )
      || ( httpx->state == HTTPX_FINISHED && !httpx->keepalive ) )

        if ( httpx->interrupted )
          httpx->state |= HTTPX_INTERRUPTED;
      }
  }
#endif
  ;

int Httpx_Update_Until_EOH(YO_HTTPX *httpx, int count)
#ifdef _HTTPX_BUILTIN
  {
    YO_BUFFER *bf = httpx->bf;
    int i = bf->count;
    bf->count += count;

    for ( ; i < bf->count; ++i )
      {
        if ( bf->at[i] == '\r' && bf->at[i+1] == '\n' )
          { if ( httpx->nline ) return i+2; httpx->nline = 1; ++i; } 
        else if ( bf->at[i] == '\n' )
          { if ( httpx->nline ) return i+1;  httpx->nline = 1; } 
        else
          httpx->nline = 0; 
        ++i;
      }
      
    return 0;
  }      
#endif
  ;
  
void Httpx_Analyze_Headers(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    int i;
    char *q, *Q, *S = httpx->bf->at;
    while (*S!='\n') ++S; /* skip HTTP/1.x line */
    q = ++S;
    for (;;)

          }
        S = ++q;
      }
  }
#endif
  ;
  
void Cbk_Httpx_Getting_Content(YO_HTTPX *httpx, int error, int count)
#ifdef _HTTPX_BUILTIN
  {
    int L;
    YO_BUFFER *bf = httpx->bf;

    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN);
        return;
      }
      

    Httpx_Aio_Recv(httpx, bf->at, bf->capacity, Yo_MIN(httpx->left,bf->capacity)
                          ,Cbk_Httpx_Getting_Content);
  }
#endif
  ;

void Cbk_Http_Getting_Chunked(YO_HTTPX *httpx, int error, int count)
#ifdef _HTTPX_BUILTIN
  {
    YO_BUFFER *bf = httpx->bf;
    int iterate = 0;

    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN);
        return;
      }

    httpx->state = HTTPX_FINISHED;
    Httpx_Do_Callback(httpx,0);  
  }
#endif
  ;
    
void Cbk_Httpx_Getting_Headers(YO_HTTPX *httpx, int error, int count)
#ifdef _HTTPX_BUILTIN
  {
    YO_BUFFER *bf = httpx->bf;
    int eoh;
    
    httpx->state = HTTPX_GETTING_HEADERS;
    
    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN);

    
    Buffer_Grow_Reserve(bf,bf->count + 512);
    Httpx_Aio_Recv(httpx, bf->at+bf->count, 512, 1, Cbk_Httpx_Getting_Headers);    
  }
#endif
  ;
  
void Cbk_Httpx_Requested(YO_HTTPX *httpx, int error)
#ifdef _HTTPX_BUILTIN
  {
    httpx->state = HTTPX_REQUESTED;

    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN);

    
    Httpx_Aio_Recv(httpx, httpx->bf->at, 1023, 12 /* lengthof HTTP/1.1 200 */
                          ,Cbk_Httpx_Getting_Headers);    
  }
#endif
  ;
  
void Cbk_Httpx_Post(YO_HTTPX *httpx, int error)
#ifdef _HTTPX_BUILTIN
  {
    YO_BUFFER *bf = httpx->bf;
    int i;

    if ( httpx->state != HTTPX_SENDING_POSTDATA )
      {
        bf->count = 0;
        httpx->left = httpx->poststrm?Oj_Available(httpx->poststrm):0;
      }

    httpx->left -= i;
    Httpx_Aio_Send(httpx, bf->at, i,
                          httpx->left ? Cbk_Httpx_Post : Cbk_Httpx_Requested);
  }
#endif
  ;
    
void Cbk_Httpx_Connected(YO_HTTPX *httpx, int error)
#ifdef _HTTPX_BUILTIN
  {
    httpx->state = HTTPX_CONNECTED;

    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN

                           (httpx->method == HTTPX_POST || httpx->method == HTTPX_PUT ) 
                                ?Cbk_Httpx_Post
                                :Cbk_Httpx_Requested);    
  }
#endif
  ;
  
void Cbk_Httpx_Proxy_Connected(YO_HTTPX *httpx, int error)
#ifdef _HTTPX_BUILTIN
  {
    httpx->state = HTTPX_PROXY_CONNECTED;

    if ( error )
      {
        Httpx_Do_Callback(httpx,HTTPX_BROKEN
                               |((error&TCP_PERMANENT_ERROR)?HTTPX_PERMANENT_ERROR:0));
        return;
      }
      
    Httpx_Do_Callback(httpx,HTTPX_PROXY_CONNECTED);
    
    /// auth / ssl connect
    Cbk_Httpx_Connected(httpx,error);
  }
#endif
  ;
  
void Httpx_Connect(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    if ( httpx->keepalive && httpx->netchnl )
      {
        Httpx_Aio_Send(httpx, httpx->bf->at, httpx->bf->count,
                     (httpx->method == HTTPX_POST || httpx->method == HTTPX_PUT) 
                          ?Cbk_Httpx_Post

          Tcp_Aio_Connect(httpx->netchnl,httpx->url->host,httpx->url->port
                              ,Cbk_Httpx_Connected,httpx);
      }
  }
#endif
  ;
  
void Httpx_Query(YO_HTTPX *httpx, int method, char *uri, YO_DICTO *hdrs, void *poststrm, void *contstrm, int maxcount)
#ifdef _HTTPX_BUILTIN
  {
    if ( httpx->status_text ) { free(httpx->status_text); httpx->status_text = 0; }
    httpx->interrupted = 0;
    httpx->status = 0;
    httpx->method = method;
    httpx->maxcount = maxcount?maxcount:INT_MAX;

    Build_Http_Request(httpx,method,uri,hdrs);
    Httpx_Connect(httpx);
  }
#endif
  ;
  
#define Httpx_Client(Url,Flags) Httpx_Client_Callback(Url,Flags,0,0)
YO_HTTPX *Httpx_Client_Callback(char *url,int flags, httpx_collback_t callback, void *cbkobj)
#ifdef _HTTPX_BUILTIN
  {
    YO_HTTPX *httpx = __Object_Dtor(sizeof(YO_HTTPX),YO_HTTPX_Destruct);
    httpx->url = __Retain(Url_Parse(url));
    
    if ( flags & HTTPX_ASYNC )
      httpx->async = 1;
    if ( flags & HTTPX_KEEPALIVE )
      httpx->keepalive = 1;
    if ( flags & HTTPX_LEGACY_10 )
      httpx->legacy10 = 1;
    
    if ( httpx->url->proto && httpx->url->proto != URLX_HTTP  )  
      __Raise(YO_ERROR_ILLFORMED,__yoTa("unknown HTTPX protocol requested",0));

    if ( !httpx->url->port ) 
      if ( !httpx->url->proto || httpx->url->proto == URLX_HTTP ) 
        httpx->url->port = 80;
        
    if ( callback )
      {
        httpx->mon_callback = callback;
        httpx->mon_obj = __Refe(cbkobj);
      }

    return httpx;
  }
#endif
  ;

int Httpx_Perform_Query(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    if ( httpx->async ) return 0;
    while ( httpx->state != HTTPX_FINISHED && !(httpx->state&HTTPX_BROKEN) )
      {
        Tasque_Perform_Update(10,0);
      }
    return httpx->status;
  }
#endif
  ;
  
int Httpx_Head(YO_HTTPX *httpx, char *uri)
#ifdef _HTTPX_BUILTIN
  {
    int ret;
    __Auto_Release
      {
        if ( !httpx ) 
          {
            httpx = Httpx_Client(uri,0);
            uri = 0;
          }
        Httpx_Query(httpx,HTTPX_GET,uri,0,0,0,0);
        ret = Httpx_Perform_Query(httpx);
      }
    return ret;
  }
#endif
  ;
  
int Httpx_Get(YO_HTTPX *httpx, char *uri, YO_DICTO *params, void *contstrm, int maxcount)
#ifdef _HTTPX_BUILTIN
  { 
    int ret;
    __Auto_Release
      {
        if ( !httpx ) 
          {

        ret = Httpx_Perform_Query(httpx);
      }
    return ret;
  }
#endif
  ;
  
int Httpx_Post(YO_HTTPX *httpx, char *uri, YO_DICTO *params, void *contstrm, int maxcount)
#ifdef _HTTPX_BUILTIN
  {
    int ret;
    __Auto_Release
      {
        void *poststrm = 0;
        if ( !httpx ) 

        ret = Httpx_Perform_Query(httpx);
      }
    return ret;
  }
#endif
  ;
  
int Httpx_Content_Length(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    char *foo;
    if ( httpx->hdrs )
      if ( foo = Dicto_Get(httpx->hdrs,"Content-Length",0) )
        {
          return Str_To_Int(foo);
        }
    __Raise(YO_ERROR_ILLFORMED,"httpx client doesn´t have required headers");
  }
#endif
  ;
  
void *Httpx_Content_Md5(YO_HTTPX *httpx)
#ifdef _HTTPX_BUILTIN
  {
    char *foo;
    if ( httpx->hdrs )
      if ( foo = Dicto_Get(httpx->hdrs,"Content-MD5",0) )
        {
          return Str_Base64_Decode(foo,0);
        }
    return 0;
  }
#endif
  ;

YO_DICTO *Httpx_Hdrs_Set_Range(YO_DICTO *dicto, int offs, int len)
#ifdef _HTTPX_BUILTIN
  {
    if ( !dicto ) dicto = Dicto_Ptrs();
    Dicto_Put(dicto,"Range",__Format_Npl("bytes=%d-%d",offs,offs+len-1));
    return dicto;
  }
#endif
  ;
  
#endif /* C_once_DAA1D391_392F_467C_B5A8_6C8D0D3A9DCC */

*/

#ifndef C_once_9629B105_86D6_4BF5_BAA2_62AB1ACE54EC
#define C_once_9629B105_86D6_4BF5_BAA2_62AB1ACE54EC

#ifdef _LIBYOYO
#define _YO_LOGOUT_BUILTIN
#endif

#include "yoyo.hc"
#include "file.hc"

enum 
  {
    YO_LOG_ERROR   = 0,
    YO_LOG_WARN    = 10,
    YO_LOG_INFO    = 20,
    YO_LOG_DEBUG   = 50,
    YO_LOG_ALL     = 100,
  };

#ifdef _YO_LOGOUT_BUILTIN
static clock_t YO_Log_Clock = 0;
static int YO_Log_Line_No = 0;
static int YO_Log_Fd = -1;
static int YO_Log_Opt = 0;
int YO_Log_Level = YO_LOG_INFO;
/* static int YO_Log_Pid = 0; */
#else
int YO_Log_Level;
#endif

enum
  {
    YO_LOG_DATESTAMP = 1 << 16,
    YO_LOG_PID       = 1 << 17,
    YO_LOG_DATEMARK  = 1 << 18,
    YO_LOG_LINENO    = 1 << 19,
    YO_LOG_LEVEL     = 1 << 20,
  };
  
void Close_Log()
#ifdef _YO_LOGOUT_BUILTIN  
  {
    if ( YO_Log_Fd >= 0 )
      {
        close(YO_Log_Fd);
        YO_Log_Fd = -1;
      }
  }
#endif
  ;
  
void Append_Log(char *logname, int opt)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    Close_Log();
    Create_Required_Dirs(logname);
    YO_Log_Fd = Open_File_Raise(logname,O_CREAT|O_APPEND|O_WRONLY);
    YO_Log_Opt = opt;
    YO_Log_Level = opt & 0x0ff;
  }
#endif
  ;
  
void Rewrite_Log(char *logname, int opt)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    Close_Log();
    Create_Required_Dirs(logname);
    YO_Log_Fd = Open_File_Raise(logname,O_CREAT|O_APPEND|O_WRONLY|O_TRUNC);
    YO_Log_Opt = opt;
    YO_Log_Level = opt & 0x0ff;
  }
#endif
  ;
  
void Set_Logout_Opt(int opt)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    YO_Log_Opt = opt;
    YO_Log_Level = opt & 0x0ff;
  }
#endif
  ;

#define Log_Level(L) (YO_Log_Level<L)

void Logout(int level, char *text)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    if ( level <= YO_Log_Level )
      __Xchg_Interlock
        {        
          int log_fd = YO_Log_Fd >= 0 ? YO_Log_Fd : fileno(stderr);
          char mark[80] = {0};
          int len = strlen(text);
          if ( YO_Log_Opt & YO_LOG_DATESTAMP )
            {
              clock_t t = clock();
              if ( t - YO_Log_Clock > CLOCKS_PER_SEC )
                {
                  YO_Log_Clock = t;
                  sprintf(mark, "%%clocks%% %.3f\n",(double)YO_Log_Clock/CLOCKS_PER_SEC);
                  Write_Out(log_fd,mark,strlen(mark));
                }
            }
          if ( YO_Log_Opt & (YO_LOG_LEVEL) )
            {
              if ( level == YO_LOG_ERROR )
                Write_Out(log_fd,"{error} ",8);
              else if ( level == YO_LOG_WARN )
                Write_Out(log_fd,"{warn!} ",8);
              else if ( level == YO_LOG_INFO )
                Write_Out(log_fd,"{info!} ",8);
              else
                Write_Out(log_fd,"{debug} ",8);
            }
          if ( YO_Log_Opt & (YO_LOG_DATEMARK|YO_LOG_PID|YO_LOG_LINENO) )
            {
              int i = 1;
              mark[0] = '[';
              if ( YO_Log_Opt & YO_LOG_LINENO )
                i += sprintf(mark+i,"%4d",YO_Log_Line_No);
              if ( YO_Log_Opt & YO_LOG_PID ) 
                {
                  int YO_Log_Pid = getpid();
                  if ( i > 1 ) mark[i++] = ':';
                  i += sprintf(mark+i,"%5d",YO_Log_Pid);
                }
              if ( YO_Log_Opt & YO_LOG_DATEMARK ) 
                {
                  time_t t = time(0);
                  struct tm *tm = localtime(&t);
                  if ( i > 1 ) mark[i++] = ':';
                  i += sprintf(mark+i,"%02d%02d%02d/%02d:%02d",
                          tm->tm_mday,tm->tm_mon+1,(tm->tm_year+1900)%100,
                          tm->tm_hour,tm->tm_min);
                }
              mark[i++] = ']';
              mark[i++] = ' ';
              mark[i] = 0;  
              Write_Out(log_fd,mark,i);
            }
          ++YO_Log_Line_No;
          Write_Out(log_fd,text,len);
          if ( !len || text[len-1] != '\n' )
            Write_Out(log_fd,"\n",1);
        }
  }
#endif
  ;
  
void Logoutf(int level, char *fmt, ...)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    if ( level <= YO_Log_Level )
      {
        va_list va;
        char *text;
        va_start(va,fmt);
        text = Yo_Format_(fmt,va);
        Logout(level,text);
        free(text);
        va_end(va);
      }
  }
#endif
  ;

#define Logout_Debug(S) if (YO_Log_Level<YO_LOG_DEBUG); else Logout(YO_LOG_DEBUG,S)
#define Log_Debug if (YO_Log_Level<YO_LOG_DEBUG); else Log_Debug_
void Log_Debug_(char *fmt, ...)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    va_list va;
    char *text;
    va_start(va,fmt);
    text = Yo_Format_(fmt,va);
    Logout(YO_LOG_DEBUG,text);
    free(text);
    va_end(va);
  }
#endif
  ;


#define Logout_Info(S) if (YO_Log_Level<YO_LOG_INFO); else Logout(YO_LOG_INFO,S)
#define Log_Info if (YO_Log_Level<YO_LOG_INFO); else Log_Info_
void Log_Info_(char *fmt, ...)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    va_list va;
    char *text;
    va_start(va,fmt);
    text = Yo_Format_(fmt,va);
    Logout(YO_LOG_INFO,text);
    free(text);
    va_end(va);
  }
#endif
  ;

#define Logout_Warning(S) if (YO_Log_Level<YO_LOG_WARN); else Logout(YO_LOG_WARN,S)

#define Log_Warning if (YO_Log_Level<YO_LOG_WARN); else Log_Warning_
void Log_Warning_(char *fmt, ...)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    va_list va;
    char *text;
    va_start(va,fmt);
    text = Yo_Format_(fmt,va);
    Logout(YO_LOG_WARN,text);
    free(text);
    va_end(va);
  }
#endif
  ;

#define Logout_Error(S) if (YO_Log_Level<YO_LOG_ERROR); else Logout(YO_LOG_ERROR,S)
/*#define Log_Error if (YO_Log_Level<YO_LOG_ERROR); else Log_Error_*/
void Log_Error(char *fmt, ...)
#ifdef _YO_LOGOUT_BUILTIN  
  {
    va_list va;
    char *text;
    va_start(va,fmt);
    text = Yo_Format_(fmt,va);
















    Logout(YO_LOG_ERROR,text);
    free(text);
    va_end(va);
  }
#endif
  ;

#endif /* C_once_9629B105_86D6_4BF5_BAA2_62AB1ACE54EC */

*/

#ifndef C_once_9570D5A2_F57C_4879_851D_6EC6959C9420
#define C_once_9570D5A2_F57C_4879_851D_6EC6959C9420

#ifdef _LIBYOYO
#define _YO_LZSS_BUILTIN
#endif

#include "yoyo.hc"
#include "buffer.hc"

#ifdef _YO_LZSS_BUILTIN
enum 
  {
    LZSS_MIN_LEN = 4,
    LZSS_MAX_LEN = 15,
    LZSS_TABLE_MOD = 4095, /*4095, */
    LZSS_TABLE_LEN = LZSS_TABLE_MOD+1,
  };
#endif

int LZSS_Search_Index(char **table_S, char**iE, char* val, int strong, int *p_l, int maxl)
#ifdef _YO_LZSS_BUILTIN
  {
    char **iS = table_S;
    int len = iE - iS;
    int half;
    char ** middle;
    int  l = 0, ll = 0;
    if (p_l) *p_l = 0;

    if ( p_l ) *p_l = l;
    return iS-table_S;
  }
#endif
  ;

void LZSS_Replace_String(char **table, char *in_b, int r_i)
#ifdef _YO_LZSS_BUILTIN
  {
    int l, o_idx, idx;
    if (r_i >= LZSS_TABLE_MOD) // replace
      {
        char *p = in_b+(r_i-LZSS_TABLE_MOD);
        o_idx = LZSS_Search_Index(table,table+LZSS_TABLE_MOD,p,1,0,LZSS_MAX_LEN);

        table[idx] = in_b+r_i;
      }
  }
#endif
  ;

short LZSS_Update_Table(char **table, char *in_b, int _in_i, int out_l)
#ifdef _YO_LZSS_BUILTIN
  {
    int code = 0, idx = 0, s_i, l=0;
    char **table_R;
    int r_i = _in_i-(LZSS_MAX_LEN-1);  // old (will replaced) string
    int t_i = _in_i;                   // encoded string
    int maxl = (out_l >= LZSS_MAX_LEN ? LZSS_MAX_LEN : out_l);

    return code;
  }
#endif
  ;

int LZSS_Compress(void *_in_b, int in_b_len, void *_out_b, int out_b_len)
#ifdef _YO_LZSS_BUILTIN
  {
    
    char *in_b = _in_b;
    unsigned char *out_b = _out_b;
    char **table = 0;
    int  out_i = 4, in_i = 0;
    unsigned char *cnt_p = 0;

    free(table);
    return out_i;
  }
#endif
  ;

int LZSS_Compress_Inplace(void *buf, int in_len)
#ifdef _YO_LZSS_BUILTIN
  {
    void *b = Yo_Malloc_Npl(in_len);
    int q = LZSS_Compress(buf,in_len,b,in_len);
    if ( q > 0 )
      memcpy(buf,b,q);
    free(b);
    return q;
  }
#endif
  ;
  
int LZSS_Decompress(void *_in_b, int in_b_len, void *_out_b, int out_b_len)
#ifdef _YO_LZSS_BUILTIN
  {
    unsigned char *in_b = _in_b;
    char *out_b = _out_b;
    int in_i = 0;
    int out_i = 0;
    
    int original_len = Four_To_Unsigned(in_b);

    if ( out_i != original_len ) out_i = -out_i;
    return out_i;
  }
#endif
  ;

int LZSS_Decompress_Inplace(void *buf, int in_len, int max_len)
#ifdef _YO_LZSS_BUILTIN
  {
    void *b = Yo_Malloc_Npl(max_len);
    int q = LZSS_Decompress(buf,in_len,b,max_len);
    if ( q > 0 )
      memcpy(buf,b,q);
    free(b);
    return q;
  }
#endif
  ;

void Buffer_LZSS_Compress(YO_BUFFER *bf)
#ifdef _YO_LZSS_BUILTIN
  {
    void *b = Yo_Malloc_Npl(bf->count);
    int q = LZSS_Compress(bf->at,bf->count,b,bf->count);
    
    if ( q > 0 )
      {
        memcpy(bf->at,b,q);
        Buffer_Resize(bf,q);
      }
    free(b);
    
    if ( q < 0 )
      __Raise(YO_ERROR_COMPRESS_DATA,"uncompressable data");
  }
#endif
  ;

void Buffer_LZSS_Decompress(YO_BUFFER *bf)
#ifdef _YO_LZSS_BUILTIN
  {
    int sz = Four_To_Unsigned(bf->at);
    if ( sz > bf->count*30 ) 
      __Raise(YO_ERROR_CORRUPTED,"is not LZSS compressed buffer"); 
    else
      {
        void *b = Yo_Malloc_Npl(sz);
        int q = LZSS_Decompress(bf->at,bf->count,b,sz);
    
        if ( q > 0 )
          {
            Buffer_Resize(bf,q);
            memcpy(bf->at,b,q);
          }
        free(b);
    
        if ( q < 0 )
          __Raise(YO_ERROR_DECOMPRESS_DATA,"failed to decompress buffer");
      }
  }
#endif
  ;

#endif /* C_once_9570D5A2_F57C_4879_851D_6EC6959C9420 */

*/

#ifndef C_once_C5021104_5DB9_4FCC_BAFC_AFB22BD458D3
#define C_once_C5021104_5DB9_4FCC_BAFC_AFB22BD458D3

#ifdef _LIBYOYO
#define _YO_MD5_BUILTIN
#endif

#include "yoyo.hc"
#include "crc.hc"

typedef struct _YO_MD5
  {
    uint_t state[4];   /* state (ABCD) */
    uint_t count[2];   /* number of bits, modulo 2^64 (lsb first) */
    int    finished;
    byte_t buffer[64];
  } YO_MD5;

typedef YO_MD5 YO_MD5_SIGNER;

void *Md5_Clone(YO_MD5 *md5)
#ifdef _YO_MD5_BUILTIN
  {
    return __Clone(sizeof(YO_MD5),md5);
  }
#endif
  ;

void * Md5_Start(YO_MD5 *md5)
#ifdef _YO_MD5_BUILTIN
  {
    memset(md5,0,sizeof(*md5));
    md5->state[0] = 0x67452301; 
    md5->state[1] = 0xefcdab89; 
    md5->state[2] = 0x98badcfe; 
    md5->state[3] = 0x10325476;
    return md5;
  }
#endif
  ;

void Md5_Update(YO_MD5 *md5, void *data, int len);
void *Md5_Finish(YO_MD5 *md5, void *digest);

void *Md5_Init()
#ifdef _YO_MD5_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Clone_OjMID, Md5_Clone },
        {Oj_Digest_Update_OjMID, Md5_Update },
        {0}};
    
    YO_MD5 *md5 = __Object(sizeof(YO_MD5),funcs);
    return Md5_Start(md5);
  }
#endif
  ;

#define YO_MD5_INITIALIZER {{0x67452301,0xefcdab89,0x98badcfe,0x10325476},{0},0,{0}}

void *Md5_Digest(void *data, int len, void *digest)
#ifdef _YO_MD5_BUILTIN
  {
    YO_MD5 md5 = YO_MD5_INITIALIZER;
    Md5_Update(&md5,data,len);
    return Md5_Finish(&md5,digest);
  }
#endif
  ;

void *Md5_Digest_Digest(void *data, int len, void *digest)
#ifdef _YO_MD5_BUILTIN
  {
    byte_t tmp[16];
    YO_MD5 md5 = YO_MD5_INITIALIZER;
    Md5_Digest(data,len,tmp);
    Md5_Update(&md5,tmp,16);
    Md5_Update(&md5,data,len);
    return Md5_Finish(&md5,digest);
  }
#endif
  ;

#define Md5_Digest_Of(Data,Len) Md5_Digest(Data,Len,0)

#ifdef _YO_MD5_BUILTIN

  #if defined _X86 || defined __i386 || defined __x86_64
    #define Md5_Internal_Encode memcpy
    #define Md5_Internal_Decode memcpy
  #else
    void Md5_Internal_Encode(byte_t *output, uint_t *input, uint_t len) 
      {

  #define H(x, y, z) ((x) ^ (y) ^ (z))
  #define I(x, y, z) ((y) ^ ((x) | ~(z)))
  #define FF(a, b, c, d, x, s, ac) (a) += F((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)) + (b)
  #define GG(a, b, c, d, x, s, ac) (a) += G((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)) + (b)
  #define HH(a, b, c, d, x, s, ac) (a) += H((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)) + (b)
  #define II(a, b, c, d, x, s, ac) (a) += I((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)) + (b)

  void Md5_Internal_Transform(YO_MD5 *md5, void *block)
    {
      enum _S_constants
        {
          S11 = 7,
          S12 = 12,
          S13 = 17,
          S14 = 22,

  #undef I
  #undef ROTATE_LEFT
  #undef FF
  #undef GG
  #undef HH
  #undef II

  void Md5_Update(YO_MD5 *md5, void *input, int input_length)
    {
      int i, index, partLen;
      uint_t *count = md5->count;
      index = (uint_t)((count[0] >> 3) & 0x3F);
      if ((count[0] += ((uint_t)input_length << 3)) < ((uint_t)input_length << 3))
        count[1]++;
      count[1] += ((uint_t)input_length >> 29);

          index = 0;
        }
      else
        i = 0;
      memcpy(&md5->buffer[index],&((byte_t*)input)[i],input_length-i);
    }

  void *Md5_Finish(YO_MD5 *md5, void *digest)
    {
      if ( !md5->finished )
        {
          static byte_t PADDING[64] = {
            0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

          md5->finished = 1;
        }
      if ( !digest ) digest = __Malloc(16);
      Md5_Internal_Encode(digest, md5->state, 16);
      return digest;
    }

#endif /* _YO_MD5_BUILTIN */

typedef struct _YO_HMAC_MD5
  {
    YO_MD5 md5;
    byte_t ipad[64];
    byte_t opad[64];
  } YO_HMAC_MD5;

void *Hmac_Md5_Clone(YO_HMAC_MD5 *hmac)
#ifdef _YO_MD5_BUILTIN
  {
    return __Clone(sizeof(YO_HMAC_MD5),hmac);
  }
#endif
  ;

void *Hmac_Md5_Start(YO_HMAC_MD5 *hmac, void *key, int key_len)
#ifdef _YO_MD5_BUILTIN
  {
    int i;
    byte_t sum[16];
    
    if ( key_len > 64 )
      {
        Md5_Start(&hmac->md5);

    
    memset(sum,0,sizeof(sum));
    return hmac;
  }
#endif
  ;

void Hmac_Md5_Update(YO_HMAC_MD5 *hmac, void *input, int input_length)
#ifdef _YO_MD5_BUILTIN
  {
    Md5_Update(&hmac->md5,input,input_length);
  }
#endif
  ;

void Hmac_Md5_Reset(YO_HMAC_MD5 *hmac)
#ifdef _YO_MD5_BUILTIN
  {
    Md5_Start(&hmac->md5);
    Md5_Update(&hmac->md5,hmac->ipad,64);
  }
#endif
  ;

void *Hmac_Md5_Finish(YO_HMAC_MD5 *hmac, void *digest)
#ifdef _YO_MD5_BUILTIN
  {
    byte_t tmpb[16];
    Md5_Finish(&hmac->md5,tmpb);
    Md5_Start(&hmac->md5);
    Md5_Update(&hmac->md5,&hmac->opad,64);
    Md5_Update(&hmac->md5,tmpb,16);
    memset(tmpb,0,16);
    return Md5_Finish(&hmac->md5,digest);
  }
#endif
  ;

void *Hmac_Md5_Digest(void *data, int len, void *key, int key_len, void *digest)
#ifdef _YO_MD5_BUILTIN
  {
    YO_HMAC_MD5 hmac5;
    Hmac_Md5_Start(&hmac5,key,key_len);
    Md5_Update(&hmac5.md5,data,len);
    return Hmac_Md5_Finish(&hmac5,digest);
  }
#endif
  ;

void *Hmac_Md5_Init(void *key, int key_len)
#ifdef _YO_MD5_BUILTIN
  {
    static YO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Clone_OjMID, Hmac_Md5_Clone },
        {Oj_Digest_Update_OjMID, Hmac_Md5_Update },
        {0}};
    
    YO_HMAC_MD5 *md5 = __Object(sizeof(YO_HMAC_MD5),funcs);
    return Hmac_Md5_Start(md5,key,key_len);
  }
#endif
  ;

#endif /* C_once_C5021104_5DB9_4FCC_BAFC_AFB22BD458D3 */

#ifndef C_once_E5DC0CBD_6EF6_4E8C_A4F5_CF78FA971011
#define C_once_E5DC0CBD_6EF6_4E8C_A4F5_CF78FA971011

#include "yoyo.hc"
#include "string.hc"

#ifdef _LIBYOYO
#define _YO_MIME_BUILTIN
#endif

#ifdef _YO_MIME_BUILTIN
  #define _YO_MIME_BUILTIN_CODE(Code) Code
  #define _YO_MIME_EXTERN 
#else
  #define _YO_MIME_BUILTIN_CODE(Code)
  #define _YO_MIME_EXTERN extern
#endif

enum
  {
    YO_MIME_NONE  = __FOUR_CHARS('`','`','`','`'),
    YO_MIME_OCTS  = __FOUR_CHARS('O','C','T','S'),
    YO_MIME_JPEG  = __FOUR_CHARS('J','P','E','G'),
    YO_MIME_PNG   = __FOUR_CHARS('x','P','N','G'),
    YO_MIME_GIF   = __FOUR_CHARS('x','G','I','F'),
    YO_MIME_PICT  = __FOUR_CHARS('P','I','C','T'),
    YO_MIME_HTML  = __FOUR_CHARS('H','T','M','L'),
    YO_MIME_TEXT  = __FOUR_CHARS('T','E','X','T'),
    YO_MIME_GZIP  = __FOUR_CHARS('G','Z','I','P'),
    YO_MIME_PKZIP = __FOUR_CHARS('x','Z','I','P'),
    YO_MIME_7ZIP  = __FOUR_CHARS('7','Z','I','P'),
    YO_MIME_APP   = __FOUR_CHARS('x','A','P','P'),
    YO_MIME_JS    = __FOUR_CHARS('x','x','J','S'),
    YO_MIME_CSS   = __FOUR_CHARS('x','C','S','S'),
    YO_MIME_EXE   = __FOUR_CHARS('x','E','X','E'),
    YO_MIME_JSON  = __FOUR_CHARS('J','S','O','N'),
    YO_MIME_UNKNOWN = -1,
  };

typedef struct _YO_EXT_MAP_RECORD
  {
    char *ext;
    int   extlen;
    int   code;
  } YO_EXT_MAP_RECORD; 

_YO_MIME_EXTERN YO_EXT_MAP_RECORD Mime_Ext_Map[] 
#ifdef _YO_MIME_BUILTIN
  = { 
    {".html", 5, YO_MIME_HTML},
    {".htm",  4, YO_MIME_HTML},
    {".txt",  4, YO_MIME_TEXT},
    {".jpeg", 5, YO_MIME_JPEG},
    {".jpg",  4, YO_MIME_JPEG},
    {".png",  4, YO_MIME_PNG},
    {".gif",  4, YO_MIME_GIF},
    {".zip",  4, YO_MIME_PKZIP},
    {".7z",   3, YO_MIME_7ZIP},
    {".gz",   3, YO_MIME_GZIP},
    {".exe",  4, YO_MIME_APP},
    {".js",   3, YO_MIME_JS},
    {".css",  4, YO_MIME_CSS},
    {".json", 5, YO_MIME_JSON},
    {0,0}
  }
#endif
  ;

int Mime_Code_Of_Path(char *path, int dflt)
#ifdef _YO_MIME_BUILTIN
  {
    YO_EXT_MAP_RECORD *R = Mime_Ext_Map;
    int L = strlen(path);
    for ( ; R->ext; ++R )
      {
        if ( L >= R->extlen && !strncmp_I(path+L-R->extlen,R->ext,R->extlen) )
          return R->code;
      }
    return dflt;
  }
#endif
  ;
  
int Mime_Code_Of(char *mime_type)
#ifdef _YO_MIME_BUILTIN
  {
    int i;
    char _S[80] = {0};
    char *S = _S;
    for ( i = 0; mime_type[i] && i < sizeof(_S)-1; ++i ) _S[i] = Tolower(mime_type[i]);
    if ( !strncmp(S,"application/",12) )
      {
        S += 12;
        if ( !strncmp(S,"x-",2) ) S +=2;
        if ( !strcmp(S,"octet-stream") ) return YO_MIME_OCTS;
        if ( !strcmp(S,"javascript") )   return YO_MIME_JS;
        if ( !strcmp(S,"msdownload") )   return YO_MIME_EXE;
        if ( !strcmp(S,"json") )         return YO_MIME_JSON;
        if ( !strcmp(S,"gzip") )         return YO_MIME_GZIP;
        if ( !strcmp(S,"zip") )          return YO_MIME_PKZIP;
        if ( !strcmp(S,"7zip") )         return YO_MIME_7ZIP;
        return YO_MIME_APP;
      }
    else if ( !strncmp(S,"text/",5) )
      {
        S += 5;
        if ( !strncmp(S,"x-",2) ) S +=2;
        if ( !strcmp(S,"html") ) return YO_MIME_HTML;
        if ( !strcmp(S,"css") )   return YO_MIME_CSS;
        if ( !strcmp(S,"javascript") ) return YO_MIME_JS;
        if ( !strcmp(S,"json") ) return YO_MIME_JSON;
        else return YO_MIME_TEXT;
      }
    else if ( !strncmp(S,"image/",6) )
      {
        S += 6;
        if ( !strncmp(S,"x-",2) ) S +=2;
        if ( !strcmp(S,"jpeg") ) return YO_MIME_JPEG;
        if ( !strcmp(S,"png") )  return YO_MIME_PNG;
        if ( !strcmp(S,"gif") )  return YO_MIME_GIF;
        return YO_MIME_PICT;
      }
    return YO_MIME_NONE;
  }
#endif
  ;

int Mime_Is_Image(int mime)
#ifdef _YO_MIME_BUILTIN
  {
    switch(mime)
      {
        case YO_MIME_JPEG:  
        case YO_MIME_PNG:   
        case YO_MIME_GIF: 
        case YO_MIME_PICT: 
          return 1;
      }
    return 0;
  }
#endif
  ;
  
int Mime_Is_Compressed(int mime)
#ifdef _YO_MIME_BUILTIN
  {
    switch(mime)
      {
        case YO_MIME_JPEG:  
        case YO_MIME_PNG:   
        case YO_MIME_GIF: 
        case YO_MIME_GZIP: 
        case YO_MIME_PKZIP: 
        case YO_MIME_7ZIP: 
          return 1;
      }
    return 0;
  }
#endif
  ;
  
int Mime_Is_Text(int mime)
#ifdef _YO_MIME_BUILTIN
  {
    switch(mime)
      {
        case YO_MIME_HTML:
        case YO_MIME_TEXT:
        case YO_MIME_JS:
        case YO_MIME_CSS:
        case YO_MIME_JSON:
          return 1;
      }
    return 0;
  }
#endif
  ;
  
int Mime_Is_Binary(int mime)
#ifdef _YO_MIME_BUILTIN
  {
    return !Mime_Is_Text(mime);
  }
#endif
  ;
  
#define Mime_String_Of_Npl(Mime) Str_Copy_Npl(Mime_String_Of(Mime),-1)
char *Mime_String_Of(int mime)
#ifdef _YO_MIME_BUILTIN
  {
    switch(mime)
      {
        case YO_MIME_OCTS: return "application/octet-stream";
        case YO_MIME_JPEG: return "image/jpeg";
        case YO_MIME_PNG:  return "image/png";
        case YO_MIME_GIF:  return "image/gif";
        case YO_MIME_PICT: return "image/octet-stream";
        case YO_MIME_HTML: return "text/html";
        case YO_MIME_TEXT: return "text/plain";
        case YO_MIME_GZIP: return "application/x-gzip";
        case YO_MIME_PKZIP:return "application/zip";
        case YO_MIME_7ZIP: return "application/x-7zip";
        case YO_MIME_APP:  return "application/octet-stream";
        case YO_MIME_CSS:  return "text/css";
        case YO_MIME_JS:   return "text/javascript";
        case YO_MIME_EXE:  return "application/x-msdownload";
        case YO_MIME_JSON: return "application/json";
      }
    return "application/octet-stream";
  }
#endif
  ;

_YO_MIME_EXTERN char Oj_Mimetype_Of_OjMID[] _YO_MIME_BUILTIN_CODE( = "mimetype_of/@"); 
int Oj_Mimetype_Of(void *o) _YO_MIME_BUILTIN_CODE(
  { return ((int(*)(void*))Yo_Find_Method_Of(&o,Oj_Mimetype_Of_OjMID,YO_RAISE_ERROR))
        (o); });
  
#endif /* C_once_E5DC0CBD_6EF6_4E8C_A4F5_CF78FA971011 */