/* This file was generated by the Hex-Rays decompiler version 7.7.0.220118.
   Copyright (c) 2007-2021 Hex-Rays <[email protected]>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

void (*init_proc())(void);
__int64 __fastcall sub_4009E8(); // weak
// int printf(const char *format, ...);
// void *memset(void *s, int c, size_t n);
// int close(int fd);
// int puts(const char *s);
// void __noreturn exit(int status);
// int putchar(int c);
// ssize_t read(int fd, void *buf, size_t nbytes);
// void *malloc(size_t size);
// int __fastcall __libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// void free(void *ptr);
// int sprintf(char *s, const char *format, ...);
// __off_t lseek(int fd, __off_t offset, int whence);
// int atoi(const char *nptr);
// void *memcpy(void *dest, const void *src, size_t n);
// int __fxstat(int ver, int fildes, struct stat *stat_buf);
// int *__errno_location(void);
// void *calloc(size_t nmemb, size_t size);
// void *dlopen(const char *file, int mode);
// void *dlsym(void *handle, const char *name);
// int ftruncate(int fd, __off_t length);
// int fprintf(FILE *stream, const char *format, ...);
// ssize_t write(int fd, const void *buf, size_t n);
// int open(const char *file, int oflag, ...);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
__int64 (**call_gmon_start())(void);
__int64 *_do_global_dtors_aux();
void frame_dummy();
__int64 __fastcall init_libssl(_QWORD, _QWORD, _QWORD); // weak
int __fastcall print_error(const char *a1, int a2);
unsigned __int64 __fastcall print_error_ex(const char *a1, int a2);
__int64 __fastcall open_read(const char *a1);
__int64 __fastcall open_write(const char *a1);
__int64 __fastcall open_read_write(const char *a1);
__int64 __fastcall get_file_curr_size(int a1, __off_t *a2);
__int64 __fastcall get_pk_data(const char *a1, void **a2);
__int64 __fastcall create_rsa_obj(__int64 a1, _QWORD *a2);
__int64 __fastcall rsa_decrypt(__int64 a1, __int64 a2, unsigned int a3, void **a4, _DWORD *a5);
__int64 __fastcall extr_data(const char *a1, void **a2, _DWORD *a3);
__int64 __fastcall dump_data(const char *a1, const void *a2, int a3);
__int64 __fastcall extract_encr_key(int a1, void **a2, int a3);
__int64 __fastcall truncate_encr_file(int a1, int a2);
__int64 __fastcall encrypt_simple(int a1, __int64 a2, __int64 a3, const void *a4, int a5, unsigned __int64 a6);
__int64 __fastcall decrypt_file(const char *a1, __int64 a2, __int64 a3, __int64 a4, unsigned __int64 a5);
int __cdecl main(int argc, const char **argv, const char **envp);
unsigned __int64 __fastcall sosemanuk_schedule(int *a1, const void *a2, size_t a3);
__int64 __fastcall decode32le(unsigned __int16 *a1);
unsigned __int64 __fastcall sosemanuk_init(int *a1, _DWORD *a2, const void *a3, size_t a4);
__int64 __fastcall sosemanuk_internal(unsigned int *a1);
__int64 __fastcall encode32le(__int64 a1, unsigned int a2);
void *__fastcall sosemanuk_prng(unsigned int *a1, char *a2, unsigned __int64 a3);
_BYTE *__fastcall sosemanuk_encrypt(__int64 a1, _BYTE *a2, _BYTE *a3, unsigned __int64 a4);
_BYTE *__fastcall xorbuf(_BYTE *a1, _BYTE *a2, _BYTE *a3, __int64 a4);
void _libc_csu_fini(void); // idb
void _libc_csu_init(void); // idb
int __fastcall fstat(int fildes, struct stat *stat_buf);
void (*_do_global_ctors_aux())(void);
__int64 *term_proc();
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

__int64 _CTOR_LIST__ = -1LL; // weak
__int64 (*qword_6091F0)(void) = NULL; // weak
__int64 *p_6181 = &_DTOR_END__; // weak
int mul_a[256] =
{
  0,
  -509620461,
  1805072166,
  -1979123659,
  -695767476,
  924361055,
  -1123002006,
  1552914041,
  94887064,
  -466087029,
  1848699838,
  -1884347219,
  -752831788,
  851410375,
  -1195932174,
  1495812833,
  182915481,
  -344400246,
  1634739903,
  -2131760724,
  -597655595,
  1040167110,
  -1208530701,
  1449691104,
  255905025,
  -287374830,
  1691875879,
  -2058865356,
  -641227955,
  945319006,
  -1303341973,
  1406098296,
  342303387,
  -168235640,
  2146440637,
  -1636836690,
  -1025487657,
  595559364,
  -1451787279,
  1223210210,
  297860611,
  -262196976,
  2052573477,
  -1681390026,
  -951611313,
  651714396,
  -1395611799,
  1297049722,
  511718146,
  -14681071,
  1964442660,
  -1802974409,
  -939041458,
  697864797,
  -1550816664,
  1108321659,
  455602074,
  -88596343,
  1890638012,
  -1859184721,
  -845119018,
  742346437,
  -1506298128,
  1202223587,
  684606623,
  -917402740,
  1129935801,
  -1564033878,
  -28759341,
  534177216,
  -1780605451,
  1950470886,
  761894919,
  -856271084,
  1191096097,
  -1486790606,
  -68225461,
  443627864,
  -1871068819,
  1910902398,
  573134086,
  -1011443179,
  1237213728,
  -1474187981,
  -189908150,
  355595353,
  -1623651220,
  2124858239,
  663652766,
  -971946355,
  1276755640,
  -1383698005,
  -251009070,
  278276289,
  -1700867852,
  2063671271,
  1017734660,
  -583620329,
  1463701794,
  -1230922191,
  -366081976,
  196200283,
  -2118566034,
  1613164669,
  957266588,
  -661555825,
  1385795002,
  -1291435351,
  -276179760,
  236329923,
  -2078350346,
  1702964453,
  911112093,
  -674121586,
  1574518971,
  -1136226392,
  -523691567,
  22468290,
  -1956761865,
  1791091172,
  870951685,
  -763993066,
  1484692515,
  -1176415440,
  -445725367,
  82905690,
  -1896222097,
  1868971388,
  1345685655,
  -1314240636,
  1000521649,
  -633507678,
  -2035095845,
  1731013064,
  -316288515,
  213524206,
  1435653135,
  -1274176740,
  1040540457,
  -543511494,
  -2095760829,
  1653273936,
  -394130075,
  152945270,
  1523751182,
  -1152559587,
  826650152,
  -790994629,
  -1940523198,
  1841969233,
  -406667164,
  106762103,
  1601521046,
  -1091925371,
  887255728,
  -713179741,
  -1980617766,
  1752032457,
  -496689924,
  66769903,
  1146268172,
  -1513265889,
  801479978,
  -832941511,
  -1831484352,
  1934232403,
  -113052826,
  417152117,
  1106605716,
  -1603618425,
  711082418,
  -872575327,
  -1754130216,
  1995298763,
  -52088834,
  494592237,
  1320532885,
  -1356172154,
  623021235,
  -994229344,
  -1741498919,
  2041387722,
  -207232257,
  305802732,
  1259497229,
  -1433556962,
  545607723,
  -1055219912,
  -1651177151,
  2081080914,
  -167625113,
  396226932,
  2029767688,
  -1721498853,
  325909294,
  -218942403,
  -1367563708,
  1340304727,
  -974416542,
  611605105,
  2103185552,
  -1664884861,
  382412726,
  -145430363,
  -1411678500,
  1246015951,
  -1068742150,
  567510761,
  1914494353,
  -1820126590,
  428599991,
  -132897372,
  -1533299747,
  1157921998,
  -821263109,
  781405160,
  2008744201,
  -1775972838,
  472659503,
  -38536900,
  -1589874875,
  1084465238,
  -894740381,
  724866928,
  1822224019,
  -1929174656,
  118217141,
  -426502490,
  -1172602657,
  1535397836,
  -779307015,
  806582506,
  1765487115,
  -2002453224,
  44827949,
  -483145154,
  -1078174649,
  1579389780,
  -735351967,
  901031026,
  1719402250,
  -2015088615,
  233621548,
  -328005825,
  -1325625018,
  1365466709,
  -613702048,
  989096307,
  1675371410,
  -2109477759,
  139138228,
  -371926105,
  -1252307490,
  1422164685,
  -557024520,
  1062450667
}; // weak
int mul_ia[256] =
{
  0,
  403652813,
  807305267,
  672252158,
  1614588262,
  2016668075,
  1344416085,
  1210935704,
  -1065813044,
  -663241983,
  -261719041,
  -395756750,
  -1606135126,
  -1203039641,
  -1873096039,
  -2007657900,
  703618865,
  838803452,
  435085058,
  31563727,
  1238169175,
  1371780762,
  2043836004,
  1641887401,
  -376920835,
  -242752464,
  -644471602,
  -1046911997,
  -1984688741,
  -1849995946,
  -1180004952,
  -1582969499,
  1380564578,
  1246166703,
  1649884753,
  2052619932,
  846534404,
  712660937,
  40605495,
  442816506,
  -1842264658,
  -1975646877,
  -1573927523,
  -1172273840,
  -233968440,
  -368923643,
  -1038914309,
  -635687882,
  2075779411,
  1672913310,
  1269260640,
  1403527597,
  461719605,
  59377912,
  731629574,
  865372363,
  -1144972641,
  -1546757550,
  -1948280148,
  -1815029151,
  -604130311,
  -1007488204,
  -337431606,
  -202607865,
  -1533880892,
  -1130523383,
  -1802742281,
  -1937566406,
  -995197790,
  -593413009,
  -189727599,
  -322978724,
  1693068808,
  2095410885,
  1425321531,
  1291579126,
  81168238,
  484034467,
  885524317,
  751257488,
  -1922921739,
  -1787966920,
  -1115944250,
  -1519171061,
  -312597613,
  -179215522,
  -582966368,
  -984620179,
  1293578553,
  1427452404,
  2097475850,
  1695265223,
  757520479,
  891918482,
  490231916,
  87496865,
  -153392218,
  -288085141,
  -960107627,
  -557143208,
  -1763196224,
  -1897364979,
  -1493613837,
  -1091173826,
  916689002,
  783077543,
  113053785,
  515002516,
  1453275404,
  1318091201,
  1719777599,
  2123299314,
  -550816617,
  -953912230,
  -281693020,
  -147131287,
  -1088971279,
  -1491542724,
  -1895227966,
  -1761190641,
  525586267,
  123506582,
  793595752,
  927076261,
  2138007101,
  1734354672,
  1332864526,
  1467918019,
  -510852319,
  -108903444,
  -778861806,
  -912473121,
  -2119062969,
  -1715541366,
  -1313920396,
  -1449104711,
  569768173,
  972732448,
  300644574,
  165951507,
  1103712651,
  1506152774,
  1909969336,
  1775800693,
  -931308528,
  -797827875,
  -127673309,
  -529752850,
  -1472072330,
  -1337018949,
  -1738574523,
  -2142227064,
  134588380,
  269149969,
  941303791,
  538208034,
  1748569786,
  1882607223,
  1478987401,
  1076416068,
  -1278952125,
  -1412694642,
  -2082849424,
  -1680507459,
  -738716635,
  -872983320,
  -471428074,
  -68561701,
  1941718671,
  1806894658,
  1134741180,
  1538098801,
  327217129,
  193965860,
  597585882,
  999370519,
  -1707810190,
  -2110020929,
  -1440062911,
  -1306189172,
  -100119788,
  -502854695,
  -904475865,
  -770077718,
  1514936766,
  1111710067,
  1783798157,
  1918753088,
  980463832,
  578809877,
  174993643,
  308375590,
  1159714533,
  1561368104,
  1963022038,
  1829639707,
  623083395,
  1026309966,
  356384688,
  221429629,
  -2056835799,
  -1654100508,
  -1250317030,
  -1384714793,
  -446987185,
  -44776318,
  -716897156,
  -850770767,
  1827637716,
  1960888601,
  1559300583,
  1157515562,
  215163058,
  349986943,
  1020108929,
  616751180,
  -1399361000,
  -1265093931,
  -1668681173,
  -2071547162,
  -861152386,
  -727409741,
  -55223475,
  -457565312,
  391538823,
  257501258,
  659089588,
  1061660793,
  2003485153,
  1868923180,
  1198801362,
  1601896735,
  -684813493,
  -819866746,
  -416279688,
  -12627019,
  -1223542227,
  -1357022496,
  -2029209058,
  -1627129133,
  1051080630,
  648640379,
  246986629,
  381155144,
  1587191504,
  1184226845,
  1854152419,
  1988845102,
  -18953094,
  -422474569,
  -826258359,
  -691073916,
  -1629330148,
  -2031278639,
  -1359157969,
  -1225546270
}; // weak
FILE *stderr; // idb
char completed_6183; // weak
void *plibssl; // idb
__int64 lRAND_pseudo_bytes; // weak
__int64 (__fastcall *lRSA_size)(_QWORD); // weak
__int64 (__fastcall *lPEM_read_bio_RSAPrivateKey)(_QWORD, _QWORD, _QWORD, _QWORD); // weak
__int64 lRSA_public_encrypt; // weak
__int64 (__fastcall *lERR_error_string)(_QWORD, _QWORD); // weak
__int64 (__fastcall *lRSA_private_decrypt)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD); // weak
__int64 (*lERR_get_error)(void); // weak
__int64 lPEM_read_bio_RSA_PUBKEY; // weak
__int64 (__fastcall *lBIO_new_mem_buf)(_QWORD, _QWORD); // weak


//----- (00000000004009D0) ----------------------------------------------------
void (*init_proc())(void)
{
  call_gmon_start();
  frame_dummy();
  return _do_global_ctors_aux();
}

//----- (00000000004009E8) ----------------------------------------------------
__int64 sub_4009E8()
{
  return qword_6091F0();
}
// 4009E8: using guessed type __int64 __fastcall sub_4009E8();
// 6091F0: using guessed type __int64 (*qword_6091F0)(void);

//----- (0000000000400B80) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  __libc_start_main(
    (int (__fastcall *)(int, char **, char **))main,
    v4,
    &retaddr,
    _libc_csu_init,
    _libc_csu_fini,
    a3,
    &v5);
  __halt();
}
// 400B86: positive sp value 8 has been found
// 400B8D: variable 'v3' is possibly undefined

//----- (0000000000400BAC) ----------------------------------------------------
__int64 (**call_gmon_start())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 609C08: using guessed type __int64 _gmon_start__(void);

//----- (0000000000400BD0) ----------------------------------------------------
__int64 *_do_global_dtors_aux()
{
  __int64 *result; // rax
  void (*v1)(void); // rdx

  if ( !completed_6183 )
  {
    while ( 1 )
    {
      result = p_6181;
      v1 = (void (*)(void))*p_6181;
      if ( !*p_6181 )
        break;
      ++p_6181;
      v1();
    }
    completed_6183 = 1;
  }
  return result;
}
// 6092D0: using guessed type __int64 *p_6181;
// 609AE8: using guessed type char completed_6183;

//----- (0000000000400C10) ----------------------------------------------------
void frame_dummy()
{
  ;
}

//----- (0000000000400C38) ----------------------------------------------------
__int64 init_libssl()
{
  int i; // [rsp+1Ch] [rbp-34h]
  char s[40]; // [rsp+20h] [rbp-30h] BYREF
  unsigned __int64 v4; // [rsp+48h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  plibssl = dlopen("libssl.so", 2);
  if ( plibssl )
    goto LABEL_8;
  for ( i = 0; i <= 15; ++i )
  {
    sprintf(s, "libssl.so.%d", (unsigned int)i);
    plibssl = dlopen(s, 2);
    if ( plibssl )
      break;
  }
  if ( plibssl )
  {
LABEL_8:
    lBIO_new_mem_buf = (__int64)dlsym(plibssl, "BIO_new_mem_buf");
    if ( lBIO_new_mem_buf )
    {
      lERR_get_error = (__int64)dlsym(plibssl, "ERR_get_error");
      if ( lERR_get_error )
      {
        lERR_error_string = (__int64)dlsym(plibssl, "ERR_error_string");
        if ( lERR_error_string )
        {
          lPEM_read_bio_RSA_PUBKEY = (__int64)dlsym(plibssl, "PEM_read_bio_RSA_PUBKEY");
          if ( lPEM_read_bio_RSA_PUBKEY )
          {
            lPEM_read_bio_RSAPrivateKey = (__int64)dlsym(plibssl, "PEM_read_bio_RSAPrivateKey");
            if ( lPEM_read_bio_RSAPrivateKey )
            {
              lRAND_pseudo_bytes = (__int64)dlsym(plibssl, "RAND_pseudo_bytes");
              if ( lRAND_pseudo_bytes )
              {
                lRSA_public_encrypt = (__int64)dlsym(plibssl, "RSA_public_encrypt");
                if ( lRSA_public_encrypt )
                {
                  lRSA_private_decrypt = (__int64)dlsym(plibssl, "RSA_private_decrypt");
                  if ( lRSA_private_decrypt )
                  {
                    lRSA_size = (__int64)dlsym(plibssl, "RSA_size");
                    if ( lRSA_size )
                      return 0;
                    else
                      return 10;
                  }
                  else
                  {
                    return 9;
                  }
                }
                else
                {
                  return 8;
                }
              }
              else
              {
                return 7;
              }
            }
            else
            {
              return 6;
            }
          }
          else
          {
            return 5;
          }
        }
        else
        {
          return 4;
        }
      }
      else
      {
        return 3;
      }
    }
    else
    {
      return 2;
    }
  }
  else
  {
    return 1;
  }
}
// 400C38: using guessed type __int64 __fastcall init_libssl();
// 609AF8: using guessed type __int64 lRAND_pseudo_bytes;
// 609B00: using guessed type __int64 lRSA_size;
// 609B08: using guessed type __int64 lPEM_read_bio_RSAPrivateKey;
// 609B10: using guessed type __int64 lRSA_public_encrypt;
// 609B18: using guessed type __int64 lERR_error_string;
// 609B20: using guessed type __int64 lRSA_private_decrypt;
// 609B28: using guessed type __int64 lERR_get_error;
// 609B30: using guessed type __int64 lPEM_read_bio_RSA_PUBKEY;
// 609B38: using guessed type __int64 lBIO_new_mem_buf;

//----- (0000000000400E9A) ----------------------------------------------------
int __fastcall print_error(const char *a1, int a2)
{
  int *v2; // rax

  if ( !a2 )
    return printf("[ %s ] - FAIL\n", a1);
  v2 = __errno_location();
  return printf("[ %s ] - FAIL { Errno: %d }\n", a1, (unsigned int)*v2);
}

//----- (0000000000400EE0) ----------------------------------------------------
unsigned __int64 __fastcall print_error_ex(const char *a1, int a2)
{
  __int64 error; // [rsp+18h] [rbp-98h]
  char v4[136]; // [rsp+20h] [rbp-90h] BYREF
  unsigned __int64 v5; // [rsp+A8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  if ( a2 )
  {
    error = lERR_get_error();
    lERR_error_string(error, v4);
    printf("[ %s ] - FAIL { %s }\n", a1, v4);
  }
  else
  {
    printf("[ %s ] - FAIL\n", a1);
  }
  return __readfsqword(0x28u) ^ v5;
}
// 609B28: invalid function type has been ignored
// 609B18: invalid function type has been ignored
// 609B18: using guessed type __int64 (__fastcall *lERR_error_string)(_QWORD, _QWORD);
// 609B28: using guessed type __int64 (*lERR_get_error)(void);

//----- (0000000000400F82) ----------------------------------------------------
__int64 __fastcall open_read(const char *a1)
{
  unsigned int v2; // [rsp+1Ch] [rbp-4h]

  v2 = open(a1, 0);
  if ( v2 == -1 )
    print_error("open", 1);
  return v2;
}

//----- (0000000000400FBE) ----------------------------------------------------
__int64 __fastcall open_write(const char *a1)
{
  unsigned int v2; // [rsp+1Ch] [rbp-4h]

  v2 = open(a1, 578, 384LL);
  if ( v2 == -1 )
    print_error("open", 1);
  return v2;
}

//----- (0000000000400FFF) ----------------------------------------------------
__int64 __fastcall open_read_write(const char *a1)
{
  unsigned int v2; // [rsp+1Ch] [rbp-4h]

  v2 = open(a1, 2, 384LL);
  if ( v2 == -1 )
    print_error("open", 1);
  return v2;
}

//----- (0000000000401040) ----------------------------------------------------
__int64 __fastcall get_file_curr_size(int a1, __off_t *a2)
{
  __off_t v4; // [rsp+28h] [rbp-8h]

  v4 = lseek(a1, 0LL, 2);
  if ( v4 == -1 )
  {
    print_error("lseek [end]", 1);
    return 1;
  }
  else
  {
    *a2 = v4;
    return 0;
  }
}

//----- (000000000040109B) ----------------------------------------------------
__int64 __fastcall get_pk_data(const char *a1, void **a2)
{
  __off_t nbytes; // [rsp+30h] [rbp-10h]
  int fd; // [rsp+3Ch] [rbp-4h]

  fd = open_read(a1);
  if ( fd == -1 )
  {
    print_error("open_pk_file", 0);
    return 1;
  }
  else
  {
    nbytes = lseek(fd, 0LL, 2);
    if ( nbytes == -1 )
    {
      print_error("lseek [end]", 1);
      return 2;
    }
    else if ( nbytes )
    {
      *a2 = calloc(nbytes + 1, 1uLL);
      if ( lseek(fd, 0LL, 0) == -1 )
      {
        print_error("lseek [start]", 1);
        return 4;
      }
      else if ( read(fd, *a2, nbytes) == -1 )
      {
        print_error("read", 1);
        return 5;
      }
      else
      {
        close(fd);
        return 0;
      }
    }
    else
    {
      puts("get_pk_data: key file is empty!");
      return 3;
    }
  }
}

//----- (00000000004011C8) ----------------------------------------------------
__int64 __fastcall create_rsa_obj(__int64 a1, _QWORD *a2)
{
  __int64 v4; // [rsp+28h] [rbp-8h]

  v4 = lBIO_new_mem_buf(a1, 0xFFFFFFFFLL);
  if ( v4 )
  {
    *a2 = 0LL;
    if ( lPEM_read_bio_RSAPrivateKey(v4, a2, 0LL, 0LL) )
    {
      return 0;
    }
    else
    {
      print_error_ex("PEM_read_bio_RSAPrivateKey", 1);
      return 2;
    }
  }
  else
  {
    print_error_ex("BIO_new_mem_buf", 1);
    return 1;
  }
}
// 609B38: invalid function type has been ignored
// 609B08: invalid function type has been ignored
// 609B08: using guessed type __int64 (__fastcall *lPEM_read_bio_RSAPrivateKey)(_QWORD, _QWORD, _QWORD, _QWORD);
// 609B38: using guessed type __int64 (__fastcall *lBIO_new_mem_buf)(_QWORD, _QWORD);

//----- (0000000000401262) ----------------------------------------------------
__int64 __fastcall rsa_decrypt(__int64 a1, __int64 a2, unsigned int a3, void **a4, _DWORD *a5)
{
  int v5; // eax
  int v11; // [rsp+3Ch] [rbp-4h]

  v5 = lRSA_size(a1);
  *a4 = calloc(v5, 1uLL);
  v11 = lRSA_private_decrypt(a3, a2, *a4, a1, 1LL);
  if ( v11 == -1 )
  {
    print_error_ex("RSA_public_decrypt", 1);
    return 1;
  }
  else
  {
    *a5 = v11;
    return 0;
  }
}
// 609B00: invalid function type has been ignored
// 609B20: invalid function type has been ignored
// 609B00: using guessed type __int64 (__fastcall *lRSA_size)(_QWORD);
// 609B20: using guessed type __int64 (__fastcall *lRSA_private_decrypt)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD);

//----- (00000000004012F9) ----------------------------------------------------
__int64 __fastcall extr_data(const char *a1, void **a2, _DWORD *a3)
{
  __off_t size; // [rsp+30h] [rbp-10h]
  int fd; // [rsp+3Ch] [rbp-4h]

  fd = open_read(a1);
  if ( fd == -1 )
  {
    print_error("open_read", 0);
    return 1;
  }
  else
  {
    size = lseek(fd, 0LL, 2);
    if ( size == -1 )
    {
      print_error("lseek [end]", 1);
      return 2;
    }
    else if ( size )
    {
      *a2 = malloc(size);
      if ( lseek(fd, 0LL, 0) == -1 )
      {
        print_error("lseek [start]", 1);
        return 4;
      }
      else if ( read(fd, *a2, size) == -1 )
      {
        print_error("read", 1);
        return 5;
      }
      else
      {
        *a3 = size;
        close(fd);
        return 0;
      }
    }
    else
    {
      puts("get_pk_data: private key file is empty!");
      return 3;
    }
  }
}

//----- (0000000000401428) ----------------------------------------------------
__int64 __fastcall dump_data(const char *a1, const void *a2, int a3)
{
  int fd; // [rsp+2Ch] [rbp-4h]

  fd = open_write(a1);
  if ( fd == -1 )
  {
    print_error("open_write", 0);
    return 1;
  }
  else if ( write(fd, a2, a3) == -1 )
  {
    print_error("write", 1);
    return 2;
  }
  else
  {
    close(fd);
    return 0;
  }
}

//----- (00000000004014A9) ----------------------------------------------------
__int64 __fastcall extract_encr_key(int a1, void **a2, int a3)
{
  unsigned __int64 v6; // [rsp+28h] [rbp-8h] BYREF

  if ( (unsigned int)get_file_curr_size(a1, (__off_t *)&v6) )
  {
    print_error("fstat", 1);
    return 1;
  }
  else if ( a3 <= v6 )
  {
    if ( lseek(a1, -a3, 2) == -1 )
    {
      print_error("lseek", 1);
      return 3;
    }
    else
    {
      *a2 = malloc(a3);
      if ( read(a1, *a2, a3) == -1 )
      {
        print_error("read", 1);
        return 4;
      }
      else
      {
        return 0;
      }
    }
  }
  else
  {
    puts("extract_encr_key: file size is less than the key size!");
    return 2;
  }
}

//----- (0000000000401592) ----------------------------------------------------
__int64 __fastcall truncate_encr_file(int a1, int a2)
{
  struct stat stat_buf; // [rsp+10h] [rbp-90h] BYREF

  if ( fstat(a1, &stat_buf) == -1 )
  {
    print_error("fstat", 1);
    return 1;
  }
  else if ( lseek(a1, 0LL, 0) == -1 )
  {
    print_error("lseek", 1);
    return 2;
  }
  else if ( ftruncate(a1, stat_buf.st_size - a2) == -1 )
  {
    print_error("lseek", 1);
    return 3;
  }
  else
  {
    return 0;
  }
}

//----- (0000000000401660) ----------------------------------------------------
__int64 __fastcall encrypt_simple(int a1, __int64 a2, __int64 a3, const void *a4, int a5, unsigned __int64 a6)
{
  double v8; // [rsp+28h] [rbp-2B8h]
  double v9; // [rsp+38h] [rbp-2A8h]
  unsigned __int64 v12; // [rsp+58h] [rbp-288h]
  __off_t offset; // [rsp+60h] [rbp-280h]
  int v14[100]; // [rsp+70h] [rbp-270h] BYREF
  size_t n; // [rsp+200h] [rbp-E0h]
  double v16; // [rsp+208h] [rbp-D8h]
  unsigned __int64 v17; // [rsp+210h] [rbp-D0h]
  __off_t v18; // [rsp+218h] [rbp-C8h]
  unsigned __int64 v19; // [rsp+220h] [rbp-C0h] BYREF
  unsigned __int64 v20; // [rsp+228h] [rbp-B8h]
  void *buf; // [rsp+230h] [rbp-B0h]
  int v22; // [rsp+23Ch] [rbp-A4h]
  int v23[34]; // [rsp+240h] [rbp-A0h] BYREF
  unsigned __int64 v24; // [rsp+2C8h] [rbp-18h]

  v24 = __readfsqword(0x28u);
  sosemanuk_schedule(v14, a4, a5);
  sosemanuk_init(v23, v14, 0LL, 0LL);
  if ( (unsigned int)get_file_curr_size(a1, (__off_t *)&v19) )
  {
    print_error("fstat", 1);
    return 1;
  }
  else
  {
    if ( a6 < v19 )
      v19 = a6;
    if ( v19 )
    {
      buf = malloc(0x100000uLL);
      if ( buf )
      {
        v18 = lseek(a1, 0LL, 0);
        if ( v18 == -1 )
        {
          print_error("lseek [start]", 1);
          return 10;
        }
        else
        {
          v12 = a3 << 20;
          offset = a2 << 20;
          v20 = 0LL;
          do
          {
            v17 = 0LL;
            do
            {
              if ( v17 >= v12 )
                break;
              n = read(a1, buf, 0x100000uLL);
              if ( n == -1LL )
              {
                print_error("fstat", 1);
                return 3;
              }
              sosemanuk_encrypt((__int64)v23, buf, buf, n);
              if ( lseek(a1, -(__int64)n, 1) == -1 )
              {
                print_error("lseek", 1);
                return 4;
              }
              if ( write(a1, buf, n) == -1 )
              {
                print_error("write", 1);
                return 5;
              }
              v17 += n;
            }
            while ( n > 0xFFFFF );
            v20 += v17;
            if ( v20 + offset >= v19 )
              break;
            if ( lseek(a1, offset, 1) == -1 )
            {
              print_error("lseek", 1);
              return 6;
            }
            v20 += offset;
            if ( !(v22 % 10) )
            {
              if ( (v20 & 0x8000000000000000LL) != 0LL )
                v8 = (double)(int)(v20 & 1 | (v20 >> 1)) + (double)(int)(v20 & 1 | (v20 >> 1));
              else
                v8 = (double)(int)v20;
              v16 = 100.0 * v8;
              if ( (v19 & 0x8000000000000000LL) != 0LL )
                v9 = (double)(int)(v19 & 1 | (v19 >> 1)) + (double)(int)(v19 & 1 | (v19 >> 1));
              else
                v9 = (double)(int)v19;
              v16 = v16 / v9;
              if ( v16 > 100.0 )
                v16 = 100.0;
              if ( v22 )
                putchar(13);
              printf("Progress: %f", v16);
            }
            ++v22;
          }
          while ( v20 < v19 );
          putchar(10);
          free(buf);
          return 0;
        }
      }
      else
      {
        print_error("malloc", 1);
        return 2;
      }
    }
    else
    {
      return 0;
    }
  }
}
// 401660: using guessed type int var_270[100];
// 401660: using guessed type int var_A0[34];

//----- (0000000000401B5C) ----------------------------------------------------
__int64 __fastcall decrypt_file(const char *a1, __int64 a2, __int64 a3, __int64 a4, unsigned __int64 a5)
{
  void *v10; // [rsp+30h] [rbp-20h] BYREF
  __int64 v11; // [rsp+38h] [rbp-18h] BYREF
  int v12; // [rsp+44h] [rbp-Ch] BYREF
  unsigned int v13; // [rsp+48h] [rbp-8h]
  int fd; // [rsp+4Ch] [rbp-4h]

  fd = open_read_write(a1);
  if ( fd == -1 )
  {
    print_error("open_read", 0);
    return 1;
  }
  else
  {
    v13 = lRSA_size(a2);
    if ( (unsigned int)extract_encr_key(fd, (void **)&v11, v13) )
    {
      print_error("extract_encr_key", 0);
      return 2;
    }
    else if ( (unsigned int)rsa_decrypt(a2, v11, v13, &v10, &v12) )
    {
      print_error("rsa_decrypt", 0);
      puts("decrypt_file: Is this really the right key?");
      return 3;
    }
    else if ( (unsigned int)truncate_encr_file(fd, v13) )
    {
      print_error("truncate_encr_file", 0);
      return 4;
    }
    else if ( (unsigned int)encrypt_simple(fd, a3, a4, v10, v12, a5) )
    {
      print_error("encrypt_simple", 0);
      return 5;
    }
    else
    {
      close(fd);
      return 0;
    }
  }
}
// 609B00: using guessed type __int64 (__fastcall *lRSA_size)(_QWORD);

//----- (0000000000401CA6) ----------------------------------------------------
// local variable allocation has failed, the output may be wrong!
int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v5; // [rsp+1Ch] [rbp-34h]
  unsigned __int64 v6; // [rsp+20h] [rbp-30h]
  __int64 v7; // [rsp+28h] [rbp-28h]
  __int64 v8; // [rsp+30h] [rbp-20h]
  __int64 v9; // [rsp+38h] [rbp-18h] BYREF
  __int64 v10; // [rsp+40h] [rbp-10h] BYREF
  unsigned int inited; // [rsp+4Ch] [rbp-4h]

  v5 = argc;
  if ( argc > 2 )
  {
    v8 = 0LL;
    v7 = 1LL;
    v6 = 0LL;
    if ( argc > 3 )
    {
      *(_QWORD *)&argc = argv[3];
      v8 = atoi(*(const char **)&argc);
    }
    if ( v5 > 4 )
    {
      *(_QWORD *)&argc = argv[4];
      v7 = atoi(*(const char **)&argc);
    }
    if ( v5 > 5 )
    {
      *(_QWORD *)&argc = argv[5];
      v6 = atoi(*(const char **)&argc);
    }
    inited = init_libssl(*(_QWORD *)&argc, argv, envp);
    if ( inited )
    {
      printf("init_libssl returned %d\n", inited);
      return 2;
    }
    else if ( (unsigned int)get_pk_data(argv[1], (void **)&v10) )
    {
      print_error("get_pk_data", 0);
      return 3;
    }
    else if ( (unsigned int)create_rsa_obj(v10, &v9) )
    {
      print_error("create_rsa_obj", 0);
      return 4;
    }
    else if ( (unsigned int)decrypt_file(argv[2], v9, v8, v7, v6) )
    {
      print_error("decrypt_file", 0);
      return 5;
    }
    else
    {
      return 0;
    }
  }
  else
  {
    puts("usage: encrypt <private_key> <file_to_decrypt> [<dec_step>] [<dec_size>] [<file_size>]");
    puts("       dec_step   -   number of MB to skip while encryption");
    puts("       dec_size   -   number of MB in encryption block");
    puts("       file_size  -   file size in bytes (for sparse files)\n");
    return 1;
  }
}
// 401CA6: variables would overlap: edi.4 and rdi.8
// 400C38: using guessed type __int64 __fastcall init_libssl(_QWORD, _QWORD, _QWORD);

//----- (0000000000401E2C) ----------------------------------------------------
unsigned __int64 __fastcall sosemanuk_schedule(int *a1, const void *a2, size_t a3)
{
  int v3; // eax
  int v5; // [rsp+8h] [rbp-3F8h]
  int v6; // [rsp+8h] [rbp-3F8h]
  int v7; // [rsp+8h] [rbp-3F8h]
  int v8; // [rsp+8h] [rbp-3F8h]
  int v9; // [rsp+8h] [rbp-3F8h]
  int v10; // [rsp+8h] [rbp-3F8h]
  int v11; // [rsp+8h] [rbp-3F8h]
  int v12; // [rsp+8h] [rbp-3F8h]
  int v13; // [rsp+8h] [rbp-3F8h]
  int v14; // [rsp+8h] [rbp-3F8h]
  int v15; // [rsp+8h] [rbp-3F8h]
  int v16; // [rsp+8h] [rbp-3F8h]
  int v17; // [rsp+8h] [rbp-3F8h]
  int v18; // [rsp+8h] [rbp-3F8h]
  int v19; // [rsp+Ch] [rbp-3F4h]
  int v20; // [rsp+Ch] [rbp-3F4h]
  int v21; // [rsp+Ch] [rbp-3F4h]
  int v22; // [rsp+Ch] [rbp-3F4h]
  int v23; // [rsp+Ch] [rbp-3F4h]
  int v24; // [rsp+Ch] [rbp-3F4h]
  int v25; // [rsp+Ch] [rbp-3F4h]
  int v26; // [rsp+Ch] [rbp-3F4h]
  int v27; // [rsp+Ch] [rbp-3F4h]
  int v28; // [rsp+Ch] [rbp-3F4h]
  int v29; // [rsp+Ch] [rbp-3F4h]
  int v30; // [rsp+Ch] [rbp-3F4h]
  int v31; // [rsp+Ch] [rbp-3F4h]
  int v32; // [rsp+Ch] [rbp-3F4h]
  int v33; // [rsp+10h] [rbp-3F0h]
  int v34; // [rsp+10h] [rbp-3F0h]
  int v35; // [rsp+10h] [rbp-3F0h]
  int v36; // [rsp+10h] [rbp-3F0h]
  int v37; // [rsp+10h] [rbp-3F0h]
  int v38; // [rsp+10h] [rbp-3F0h]
  int v39; // [rsp+10h] [rbp-3F0h]
  int v40; // [rsp+10h] [rbp-3F0h]
  int v41; // [rsp+10h] [rbp-3F0h]
  int v42; // [rsp+10h] [rbp-3F0h]
  int v43; // [rsp+10h] [rbp-3F0h]
  int v44; // [rsp+10h] [rbp-3F0h]
  int v45; // [rsp+10h] [rbp-3F0h]
  int v46; // [rsp+10h] [rbp-3F0h]
  int v47; // [rsp+14h] [rbp-3ECh]
  int v48; // [rsp+14h] [rbp-3ECh]
  int v49; // [rsp+14h] [rbp-3ECh]
  int v50; // [rsp+14h] [rbp-3ECh]
  int v51; // [rsp+14h] [rbp-3ECh]
  int v52; // [rsp+14h] [rbp-3ECh]
  int v53; // [rsp+14h] [rbp-3ECh]
  int v54; // [rsp+14h] [rbp-3ECh]
  int v55; // [rsp+14h] [rbp-3ECh]
  int v56; // [rsp+14h] [rbp-3ECh]
  int v57; // [rsp+14h] [rbp-3ECh]
  int v58; // [rsp+14h] [rbp-3ECh]
  int v59; // [rsp+14h] [rbp-3ECh]
  int v60; // [rsp+14h] [rbp-3ECh]
  int v61; // [rsp+18h] [rbp-3E8h]
  int v62; // [rsp+18h] [rbp-3E8h]
  int v63; // [rsp+18h] [rbp-3E8h]
  int v64; // [rsp+18h] [rbp-3E8h]
  int v65; // [rsp+18h] [rbp-3E8h]
  int v66; // [rsp+18h] [rbp-3E8h]
  int v67; // [rsp+18h] [rbp-3E8h]
  int v68; // [rsp+18h] [rbp-3E8h]
  int v69; // [rsp+18h] [rbp-3E8h]
  int v70; // [rsp+18h] [rbp-3E8h]
  int v71; // [rsp+18h] [rbp-3E8h]
  int v72; // [rsp+18h] [rbp-3E8h]
  int v73; // [rsp+18h] [rbp-3E8h]
  int v74; // [rsp+1Ch] [rbp-3E4h]
  int v75; // [rsp+1Ch] [rbp-3E4h]
  int v76; // [rsp+1Ch] [rbp-3E4h]
  int v77; // [rsp+1Ch] [rbp-3E4h]
  int v78; // [rsp+1Ch] [rbp-3E4h]
  int v79; // [rsp+1Ch] [rbp-3E4h]
  int v80; // [rsp+1Ch] [rbp-3E4h]
  int v81; // [rsp+1Ch] [rbp-3E4h]
  int v82; // [rsp+1Ch] [rbp-3E4h]
  int v83; // [rsp+1Ch] [rbp-3E4h]
  int v84; // [rsp+1Ch] [rbp-3E4h]
  int v85; // [rsp+1Ch] [rbp-3E4h]
  int v86; // [rsp+1Ch] [rbp-3E4h]
  int v87; // [rsp+20h] [rbp-3E0h]
  int v88; // [rsp+20h] [rbp-3E0h]
  int v89; // [rsp+20h] [rbp-3E0h]
  int v90; // [rsp+20h] [rbp-3E0h]
  int v91; // [rsp+20h] [rbp-3E0h]
  int v92; // [rsp+20h] [rbp-3E0h]
  int v93; // [rsp+20h] [rbp-3E0h]
  int v94; // [rsp+20h] [rbp-3E0h]
  int v95; // [rsp+20h] [rbp-3E0h]
  int v96; // [rsp+20h] [rbp-3E0h]
  int v97; // [rsp+20h] [rbp-3E0h]
  int v98; // [rsp+20h] [rbp-3E0h]
  int v99; // [rsp+20h] [rbp-3E0h]
  int v100; // [rsp+24h] [rbp-3DCh]
  int v101; // [rsp+24h] [rbp-3DCh]
  int v102; // [rsp+24h] [rbp-3DCh]
  int v103; // [rsp+24h] [rbp-3DCh]
  int v104; // [rsp+24h] [rbp-3DCh]
  int v105; // [rsp+24h] [rbp-3DCh]
  int v106; // [rsp+24h] [rbp-3DCh]
  int v107; // [rsp+24h] [rbp-3DCh]
  int v108; // [rsp+24h] [rbp-3DCh]
  int v109; // [rsp+24h] [rbp-3DCh]
  int v110; // [rsp+24h] [rbp-3DCh]
  int v111; // [rsp+24h] [rbp-3DCh]
  int v113; // [rsp+4Ch] [rbp-3B4h]
  int v114; // [rsp+50h] [rbp-3B0h]
  int v115; // [rsp+70h] [rbp-390h]
  int v116; // [rsp+74h] [rbp-38Ch]
  int v117; // [rsp+78h] [rbp-388h]
  int v118; // [rsp+7Ch] [rbp-384h]
  int v119; // [rsp+90h] [rbp-370h]
  int v120; // [rsp+94h] [rbp-36Ch]
  int v121; // [rsp+98h] [rbp-368h]
  int v122; // [rsp+9Ch] [rbp-364h]
  int v123; // [rsp+B4h] [rbp-34Ch]
  int v124; // [rsp+BCh] [rbp-344h]
  int v125; // [rsp+C4h] [rbp-33Ch]
  int v126; // [rsp+E4h] [rbp-31Ch]
  int v127; // [rsp+E8h] [rbp-318h]
  int v128; // [rsp+FCh] [rbp-304h]
  int v129; // [rsp+100h] [rbp-300h]
  int v130; // [rsp+108h] [rbp-2F8h]
  int v131; // [rsp+10Ch] [rbp-2F4h]
  int v132; // [rsp+120h] [rbp-2E0h]
  int v133; // [rsp+128h] [rbp-2D8h]
  int v134; // [rsp+12Ch] [rbp-2D4h]
  int v135; // [rsp+12Ch] [rbp-2D4h]
  int v136; // [rsp+130h] [rbp-2D0h]
  int v137; // [rsp+130h] [rbp-2D0h]
  int v138; // [rsp+130h] [rbp-2D0h]
  int v139; // [rsp+144h] [rbp-2BCh]
  int v140; // [rsp+148h] [rbp-2B8h]
  int v141; // [rsp+16Ch] [rbp-294h]
  int v142; // [rsp+170h] [rbp-290h]
  int v143; // [rsp+190h] [rbp-270h]
  int v144; // [rsp+194h] [rbp-26Ch]
  int v145; // [rsp+198h] [rbp-268h]
  int v146; // [rsp+19Ch] [rbp-264h]
  int v147; // [rsp+1B0h] [rbp-250h]
  int v148; // [rsp+1B4h] [rbp-24Ch]
  int v149; // [rsp+1B8h] [rbp-248h]
  int v150; // [rsp+1BCh] [rbp-244h]
  int v151; // [rsp+1D4h] [rbp-22Ch]
  int v152; // [rsp+1DCh] [rbp-224h]
  int v153; // [rsp+1E4h] [rbp-21Ch]
  int v154; // [rsp+204h] [rbp-1FCh]
  int v155; // [rsp+208h] [rbp-1F8h]
  int v156; // [rsp+21Ch] [rbp-1E4h]
  int v157; // [rsp+220h] [rbp-1E0h]
  int v158; // [rsp+228h] [rbp-1D8h]
  int v159; // [rsp+22Ch] [rbp-1D4h]
  int v160; // [rsp+240h] [rbp-1C0h]
  int v161; // [rsp+248h] [rbp-1B8h]
  int v162; // [rsp+24Ch] [rbp-1B4h]
  int v163; // [rsp+24Ch] [rbp-1B4h]
  int v164; // [rsp+250h] [rbp-1B0h]
  int v165; // [rsp+250h] [rbp-1B0h]
  int v166; // [rsp+250h] [rbp-1B0h]
  int v167; // [rsp+264h] [rbp-19Ch]
  int v168; // [rsp+268h] [rbp-198h]
  int v169; // [rsp+28Ch] [rbp-174h]
  int v170; // [rsp+290h] [rbp-170h]
  int v171; // [rsp+2B0h] [rbp-150h]
  int v172; // [rsp+2B4h] [rbp-14Ch]
  int v173; // [rsp+2B8h] [rbp-148h]
  int v174; // [rsp+2BCh] [rbp-144h]
  int v175; // [rsp+2D0h] [rbp-130h]
  int v176; // [rsp+2D4h] [rbp-12Ch]
  int v177; // [rsp+2D8h] [rbp-128h]
  int v178; // [rsp+2DCh] [rbp-124h]
  int v179; // [rsp+2F4h] [rbp-10Ch]
  int v180; // [rsp+2FCh] [rbp-104h]
  int v181; // [rsp+304h] [rbp-FCh]
  int v182; // [rsp+324h] [rbp-DCh]
  int v183; // [rsp+328h] [rbp-D8h]
  int v184; // [rsp+33Ch] [rbp-C4h]
  int v185; // [rsp+340h] [rbp-C0h]
  int v186; // [rsp+348h] [rbp-B8h]
  int v187; // [rsp+34Ch] [rbp-B4h]
  int v188; // [rsp+360h] [rbp-A0h]
  int v189; // [rsp+368h] [rbp-98h]
  int v190; // [rsp+36Ch] [rbp-94h]
  int v191; // [rsp+36Ch] [rbp-94h]
  int v192; // [rsp+370h] [rbp-90h]
  int v193; // [rsp+370h] [rbp-90h]
  int v194; // [rsp+370h] [rbp-90h]
  int v195; // [rsp+384h] [rbp-7Ch]
  int v196; // [rsp+388h] [rbp-78h]
  int v197; // [rsp+3ACh] [rbp-54h]
  int v198; // [rsp+3B0h] [rbp-50h]
  unsigned __int16 dest[2]; // [rsp+3D0h] [rbp-30h] BYREF
  unsigned __int16 v200; // [rsp+3D4h] [rbp-2Ch] BYREF
  unsigned __int16 v201[2]; // [rsp+3D8h] [rbp-28h] BYREF
  unsigned __int16 v202; // [rsp+3DCh] [rbp-24h] BYREF
  unsigned __int16 v203[2]; // [rsp+3E0h] [rbp-20h] BYREF
  unsigned __int16 v204; // [rsp+3E4h] [rbp-1Ch] BYREF
  unsigned __int16 v205[2]; // [rsp+3E8h] [rbp-18h] BYREF
  unsigned __int16 v206[6]; // [rsp+3ECh] [rbp-14h] BYREF
  unsigned __int64 v207; // [rsp+3F8h] [rbp-8h]

  v207 = __readfsqword(0x28u);
  if ( !a3 || a3 > 0x20 )
  {
    fprintf(stderr, "invalid key size: %lu\n", a3);
    exit(1);
  }
  memcpy(dest, a2, a3);
  if ( a3 <= 0x1F )
  {
    *((_BYTE *)dest + a3) = 1;
    if ( a3 <= 0x1E )
      memset((char *)dest + a3 + 1, 0, 31 - a3);
  }
  v5 = decode32le(dest);
  v19 = decode32le(&v200);
  v33 = decode32le(v201);
  v47 = decode32le(&v202);
  v61 = decode32le(v203);
  v74 = decode32le(&v204);
  v87 = decode32le(v205);
  v3 = decode32le(v206);
  v6 = __ROR4__(v3 ^ v74 ^ v47 ^ v5 ^ 0x9E3779B9, 21);
  v20 = __ROR4__(v6 ^ v87 ^ v61 ^ v19 ^ 0x9E3779B8, 21);
  v34 = __ROR4__(v20 ^ v3 ^ v74 ^ v33 ^ 0x9E3779BB, 21);
  v48 = __ROR4__(v34 ^ v6 ^ v87 ^ v47 ^ 0x9E3779BA, 21);
  v197 = (v6 & v20 | v34 ^ v6) ^ (v48 | v6) & (v20 ^ v48);
  v198 = v20 ^ v48 ^ v34 ^ (v6 & v20 ^ (v48 | v6) | v197 ^ v6 & v20);
  *a1 = v197 ^ v6 & v20 ^ (v48 | v6) ^ (v197 | v198);
  a1[1] = v198;
  a1[2] = v197;
  a1[3] = v20 ^ v48 ^ v34 ^ (v6 & v20 ^ (v48 | v6)) & (v6 & v20 | v34 ^ v6);
  v62 = __ROR4__(v48 ^ v20 ^ v3 ^ v61 ^ 0x9E3779BD, 21);
  v75 = __ROR4__(v62 ^ v34 ^ v6 ^ v74 ^ 0x9E3779BC, 21);
  v88 = __ROR4__(v75 ^ v48 ^ v20 ^ v87 ^ 0x9E3779BF, 21);
  v100 = __ROR4__(v88 ^ v62 ^ v34 ^ v3 ^ 0x9E3779BE, 21);
  v196 = v100 ^ v88 & v62 ^ (v100 ^ v88 & v62 ^ v75 ^ v88 ^ v62 | v75 ^ (v62 | v100));
  v195 = (v75 ^ (v62 | v100)) & (v100 ^ v88 & v62) ^ v100 ^ v88 & v62 ^ v75 ^ v88 ^ v62;
  a1[4] = v100 ^ v88 & v62 ^ v75 ^ v88;
  a1[5] = v196;
  a1[6] = v195 ^ v196 ^ v75 ^ (v62 | v100);
  a1[7] = ~v195;
  v7 = __ROR4__(v100 ^ v75 ^ v48 ^ v6 ^ 0x9E3779B1, 21);
  v21 = __ROR4__(v7 ^ v88 ^ v62 ^ v20 ^ 0x9E3779B0, 21);
  v35 = __ROR4__(v21 ^ v100 ^ v75 ^ v34 ^ 0x9E3779B3, 21);
  v49 = __ROR4__(v35 ^ v7 ^ v88 ^ v48 ^ 0x9E3779B2, 21);
  v192 = v49 | v21 & ~v7;
  v190 = v192 ^ v21;
  v193 = ~v7 ^ v192;
  v188 = v190 | ~v7;
  v191 = v21 & ~v7 ^ ~v35 ^ v49 ^ v190;
  v189 = v188 & (v193 | v21 & ~v7 ^ ~v35);
  v194 = v191 ^ v193;
  a1[8] = v189;
  a1[9] = v188 ^ v189 & v194;
  a1[10] = v21 & ~v7 ^ ~v35 ^ v49;
  a1[11] = v194 ^ v189 & v191;
  v63 = __ROR4__(v49 ^ v21 ^ v100 ^ v62 ^ 0x9E3779B5, 21);
  v76 = __ROR4__(v63 ^ v35 ^ v7 ^ v75 ^ 0x9E3779B4, 21);
  v89 = __ROR4__(v76 ^ v49 ^ v21 ^ v88 ^ 0x9E3779B7, 21);
  v101 = __ROR4__(v89 ^ v63 ^ v35 ^ v100 ^ 0x9E3779B6, 21);
  v186 = v63 ^ (v63 ^ v101) & v76;
  v187 = v89 ^ v76 ^ (v63 ^ v101 | v63);
  v184 = v186 | ~(v63 ^ v101 ^ v89 ^ v76);
  v185 = v187 | v89 ^ v63 ^ v101;
  a1[12] = v185 ^ v184 ^ v89 ^ v63 ^ v101 ^ v186;
  a1[13] = v185 ^ v184;
  a1[14] = v63 ^ v101 ^ v89 ^ v76 ^ (v186 | v89);
  a1[15] = v187;
  v8 = __ROR4__(v101 ^ v76 ^ v49 ^ v7 ^ 0x9E3779A9, 21);
  v22 = __ROR4__(v8 ^ v89 ^ v63 ^ v21 ^ 0x9E3779A8, 21);
  v36 = __ROR4__(v22 ^ v101 ^ v76 ^ v35 ^ 0x9E3779AB, 21);
  v50 = __ROR4__(v36 ^ v8 ^ v89 ^ v49 ^ 0x9E3779AA, 21);
  v183 = v50 ^ (v36 | v22) ^ v36 ^ (v50 ^ (v36 | v22) ^ v36 ^ v36 ^ v22 | v8);
  v182 = v50 ^ (v36 | v22) ^ v36 ^ v36 ^ v22 ^ v8 ^ (v50 ^ (v36 | v22) ^ v36 ^ v36 ^ v22 | v50 ^ (v36 | v22));
  a1[16] = (v183 | ~(v182 ^ v50 ^ (v36 | v22) ^ v36)) ^ v50 ^ (v36 | v22) ^ v36 ^ v36 ^ v22;
  a1[17] = v50 ^ (v36 | v22) ^ v8 & (v36 ^ v22 | v50);
  a1[18] = v50 ^ (v36 | v22) ^ v36 ^ v36 ^ v22 ^ v183 & v182;
  a1[19] = v183;
  v64 = __ROR4__(v50 ^ v22 ^ v101 ^ v63 ^ 0x9E3779AD, 21);
  v77 = __ROR4__(v64 ^ v36 ^ v8 ^ v76 ^ 0x9E3779AC, 21);
  v90 = __ROR4__(v77 ^ v50 ^ v22 ^ v89 ^ 0x9E3779AF, 21);
  v102 = __ROR4__(v90 ^ v64 ^ v36 ^ v101 ^ 0x9E3779AE, 21);
  v180 = ~v90 ^ v64 & v102 ^ v77 ^ v102 ^ v64 ^ (v102 | ~v90);
  v181 = v180 ^ (~v90 ^ v64 & v102 | ~v90 ^ v64 & v102 ^ v77 | v102 ^ v64);
  v179 = v181 ^ ~v90 ^ v64 & v102 ^ (~v90 ^ v64 & v102 ^ v77 | v102 ^ v64) ^ v102;
  a1[20] = v181;
  a1[21] = ~v90 ^ v64 & v102 ^ v77;
  a1[22] = v179;
  a1[23] = ~(~v90 ^ v64 & v102) ^ v179 & v180;
  v9 = __ROR4__(v102 ^ v77 ^ v50 ^ v8 ^ 0x9E3779A1, 21);
  v23 = __ROR4__(v9 ^ v90 ^ v64 ^ v22 ^ 0x9E3779A0, 21);
  v37 = __ROR4__(v23 ^ v102 ^ v77 ^ v36 ^ 0x9E3779A3, 21);
  v51 = __ROR4__(v37 ^ v9 ^ v90 ^ v50 ^ 0x9E3779A2, 21);
  v178 = ~v51 ^ v37 ^ (v23 ^ v9) & (v51 ^ v23);
  v177 = v51 ^ v23 | ~v51 ^ v37;
  v176 = v23 ^ v9 ^ v178 & ~v51;
  v175 = v177 ^ v178 ^ ~v51 ^ v51 ^ v23;
  a1[24] = v178;
  a1[25] = v176;
  a1[26] = v175 ^ v176 & (v23 ^ v9);
  a1[27] = (v176 | v175) ^ ~(v23 ^ v9 ^ v177);
  v65 = __ROR4__(v51 ^ v23 ^ v102 ^ v64 ^ 0x9E3779A5, 21);
  v78 = __ROR4__(v65 ^ v37 ^ v9 ^ v77 ^ 0x9E3779A4, 21);
  v91 = __ROR4__(v78 ^ v51 ^ v23 ^ v90 ^ 0x9E3779A7, 21);
  v103 = __ROR4__(v91 ^ v65 ^ v37 ^ v102 ^ 0x9E3779A6, 21);
  v173 = ~v103 ^ v91 ^ (v65 ^ ~v103) & (v103 ^ v78);
  v172 = v65 ^ ~v103 ^ v103 ^ v78 ^ v65 ^ (v65 ^ ~v103 ^ v103 ^ v78) & (~v103 ^ v91);
  v174 = v173 & (v65 ^ ~v103 ^ v103 ^ v78 ^ v65);
  v171 = v174 ^ v65 ^ ~v103;
  a1[28] = v173;
  a1[29] = v171 & v172 ^ v174 ^ (v173 | v65 ^ ~v103 ^ v103 ^ v78);
  a1[30] = ~(v172 ^ (v171 | v174));
  a1[31] = v171;
  v10 = __ROR4__(v103 ^ v78 ^ v51 ^ v9 ^ 0x9E377999, 21);
  v24 = __ROR4__(v10 ^ v91 ^ v65 ^ v23 ^ 0x9E377998, 21);
  v38 = __ROR4__(v24 ^ v103 ^ v78 ^ v37 ^ 0x9E37799B, 21);
  v52 = __ROR4__(v38 ^ v10 ^ v91 ^ v51 ^ 0x9E37799A, 21);
  v169 = (v10 & v24 | v38 ^ v10) ^ (v52 | v10) & (v24 ^ v52);
  v170 = v24 ^ v52 ^ v38 ^ (v10 & v24 ^ (v52 | v10) | v169 ^ v10 & v24);
  a1[32] = v169 ^ v10 & v24 ^ (v52 | v10) ^ (v169 | v170);
  a1[33] = v170;
  a1[34] = v169;
  a1[35] = v24 ^ v52 ^ v38 ^ (v10 & v24 ^ (v52 | v10)) & (v10 & v24 | v38 ^ v10);
  v66 = __ROR4__(v52 ^ v24 ^ v103 ^ v65 ^ 0x9E37799D, 21);
  v79 = __ROR4__(v66 ^ v38 ^ v10 ^ v78 ^ 0x9E37799C, 21);
  v92 = __ROR4__(v79 ^ v52 ^ v24 ^ v91 ^ 0x9E37799F, 21);
  v104 = __ROR4__(v92 ^ v66 ^ v38 ^ v103 ^ 0x9E37799E, 21);
  v168 = v104 ^ v92 & v66 ^ (v104 ^ v92 & v66 ^ v79 ^ v92 ^ v66 | v79 ^ (v66 | v104));
  v167 = (v79 ^ (v66 | v104)) & (v104 ^ v92 & v66) ^ v104 ^ v92 & v66 ^ v79 ^ v92 ^ v66;
  a1[36] = v104 ^ v92 & v66 ^ v79 ^ v92;
  a1[37] = v168;
  a1[38] = v167 ^ v168 ^ v79 ^ (v66 | v104);
  a1[39] = ~v167;
  v11 = __ROR4__(v104 ^ v79 ^ v52 ^ v10 ^ 0x9E377991, 21);
  v25 = __ROR4__(v11 ^ v92 ^ v66 ^ v24 ^ 0x9E377990, 21);
  v39 = __ROR4__(v25 ^ v104 ^ v79 ^ v38 ^ 0x9E377993, 21);
  v53 = __ROR4__(v39 ^ v11 ^ v92 ^ v52 ^ 0x9E377992, 21);
  v164 = v53 | v25 & ~v11;
  v162 = v164 ^ v25;
  v165 = ~v11 ^ v164;
  v160 = v162 | ~v11;
  v163 = v25 & ~v11 ^ ~v39 ^ v53 ^ v162;
  v161 = v160 & (v165 | v25 & ~v11 ^ ~v39);
  v166 = v163 ^ v165;
  a1[40] = v161;
  a1[41] = v160 ^ v161 & v166;
  a1[42] = v25 & ~v11 ^ ~v39 ^ v53;
  a1[43] = v166 ^ v161 & v163;
  v67 = __ROR4__(v53 ^ v25 ^ v104 ^ v66 ^ 0x9E377995, 21);
  v80 = __ROR4__(v67 ^ v39 ^ v11 ^ v79 ^ 0x9E377994, 21);
  v93 = __ROR4__(v80 ^ v53 ^ v25 ^ v92 ^ 0x9E377997, 21);
  v105 = __ROR4__(v93 ^ v67 ^ v39 ^ v104 ^ 0x9E377996, 21);
  v158 = v67 ^ (v67 ^ v105) & v80;
  v159 = v93 ^ v80 ^ (v67 ^ v105 | v67);
  v156 = v158 | ~(v67 ^ v105 ^ v93 ^ v80);
  v157 = v159 | v93 ^ v67 ^ v105;
  a1[44] = v157 ^ v156 ^ v93 ^ v67 ^ v105 ^ v158;
  a1[45] = v157 ^ v156;
  a1[46] = v67 ^ v105 ^ v93 ^ v80 ^ (v158 | v93);
  a1[47] = v159;
  v12 = __ROR4__(v105 ^ v80 ^ v53 ^ v11 ^ 0x9E377989, 21);
  v26 = __ROR4__(v12 ^ v93 ^ v67 ^ v25 ^ 0x9E377988, 21);
  v40 = __ROR4__(v26 ^ v105 ^ v80 ^ v39 ^ 0x9E37798B, 21);
  v54 = __ROR4__(v40 ^ v12 ^ v93 ^ v53 ^ 0x9E37798A, 21);
  v155 = v54 ^ (v40 | v26) ^ v40 ^ (v54 ^ (v40 | v26) ^ v40 ^ v40 ^ v26 | v12);
  v154 = v54 ^ (v40 | v26) ^ v40 ^ v40 ^ v26 ^ v12 ^ (v54 ^ (v40 | v26) ^ v40 ^ v40 ^ v26 | v54 ^ (v40 | v26));
  a1[48] = (v155 | ~(v154 ^ v54 ^ (v40 | v26) ^ v40)) ^ v54 ^ (v40 | v26) ^ v40 ^ v40 ^ v26;
  a1[49] = v54 ^ (v40 | v26) ^ v12 & (v40 ^ v26 | v54);
  a1[50] = v54 ^ (v40 | v26) ^ v40 ^ v40 ^ v26 ^ v155 & v154;
  a1[51] = v155;
  v68 = __ROR4__(v54 ^ v26 ^ v105 ^ v67 ^ 0x9E37798D, 21);
  v81 = __ROR4__(v68 ^ v40 ^ v12 ^ v80 ^ 0x9E37798C, 21);
  v94 = __ROR4__(v81 ^ v54 ^ v26 ^ v93 ^ 0x9E37798F, 21);
  v106 = __ROR4__(v94 ^ v68 ^ v40 ^ v105 ^ 0x9E37798E, 21);
  v152 = ~v94 ^ v68 & v106 ^ v81 ^ v106 ^ v68 ^ (v106 | ~v94);
  v153 = v152 ^ (~v94 ^ v68 & v106 | ~v94 ^ v68 & v106 ^ v81 | v106 ^ v68);
  v151 = v153 ^ ~v94 ^ v68 & v106 ^ (~v94 ^ v68 & v106 ^ v81 | v106 ^ v68) ^ v106;
  a1[52] = v153;
  a1[53] = ~v94 ^ v68 & v106 ^ v81;
  a1[54] = v151;
  a1[55] = ~(~v94 ^ v68 & v106) ^ v151 & v152;
  v13 = __ROR4__(v106 ^ v81 ^ v54 ^ v12 ^ 0x9E377981, 21);
  v27 = __ROR4__(v13 ^ v94 ^ v68 ^ v26 ^ 0x9E377980, 21);
  v41 = __ROR4__(v27 ^ v106 ^ v81 ^ v40 ^ 0x9E377983, 21);
  v55 = __ROR4__(v41 ^ v13 ^ v94 ^ v54 ^ 0x9E377982, 21);
  v150 = ~v55 ^ v41 ^ (v27 ^ v13) & (v55 ^ v27);
  v149 = v55 ^ v27 | ~v55 ^ v41;
  v148 = v27 ^ v13 ^ v150 & ~v55;
  v147 = v149 ^ v150 ^ ~v55 ^ v55 ^ v27;
  a1[56] = v150;
  a1[57] = v148;
  a1[58] = v147 ^ v148 & (v27 ^ v13);
  a1[59] = (v148 | v147) ^ ~(v27 ^ v13 ^ v149);
  v69 = __ROR4__(v55 ^ v27 ^ v106 ^ v68 ^ 0x9E377985, 21);
  v82 = __ROR4__(v69 ^ v41 ^ v13 ^ v81 ^ 0x9E377984, 21);
  v95 = __ROR4__(v82 ^ v55 ^ v27 ^ v94 ^ 0x9E377987, 21);
  v107 = __ROR4__(v95 ^ v69 ^ v41 ^ v106 ^ 0x9E377986, 21);
  v145 = ~v107 ^ v95 ^ (v69 ^ ~v107) & (v107 ^ v82);
  v144 = v69 ^ ~v107 ^ v107 ^ v82 ^ v69 ^ (v69 ^ ~v107 ^ v107 ^ v82) & (~v107 ^ v95);
  v146 = v145 & (v69 ^ ~v107 ^ v107 ^ v82 ^ v69);
  v143 = v146 ^ v69 ^ ~v107;
  a1[60] = v145;
  a1[61] = v143 & v144 ^ v146 ^ (v145 | v69 ^ ~v107 ^ v107 ^ v82);
  a1[62] = ~(v144 ^ (v143 | v146));
  a1[63] = v143;
  v14 = __ROR4__(v107 ^ v82 ^ v55 ^ v13 ^ 0x9E3779F9, 21);
  v28 = __ROR4__(v14 ^ v95 ^ v69 ^ v27 ^ 0x9E3779F8, 21);
  v42 = __ROR4__(v28 ^ v107 ^ v82 ^ v41 ^ 0x9E3779FB, 21);
  v56 = __ROR4__(v42 ^ v14 ^ v95 ^ v55 ^ 0x9E3779FA, 21);
  v141 = (v14 & v28 | v42 ^ v14) ^ (v56 | v14) & (v28 ^ v56);
  v142 = v28 ^ v56 ^ v42 ^ (v14 & v28 ^ (v56 | v14) | v141 ^ v14 & v28);
  a1[64] = v141 ^ v14 & v28 ^ (v56 | v14) ^ (v141 | v142);
  a1[65] = v142;
  a1[66] = v141;
  a1[67] = v28 ^ v56 ^ v42 ^ (v14 & v28 ^ (v56 | v14)) & (v14 & v28 | v42 ^ v14);
  v70 = __ROR4__(v56 ^ v28 ^ v107 ^ v69 ^ 0x9E3779FD, 21);
  v83 = __ROR4__(v70 ^ v42 ^ v14 ^ v82 ^ 0x9E3779FC, 21);
  v96 = __ROR4__(v83 ^ v56 ^ v28 ^ v95 ^ 0x9E3779FF, 21);
  v108 = __ROR4__(v96 ^ v70 ^ v42 ^ v107 ^ 0x9E3779FE, 21);
  v140 = v108 ^ v96 & v70 ^ (v108 ^ v96 & v70 ^ v83 ^ v96 ^ v70 | v83 ^ (v70 | v108));
  v139 = (v83 ^ (v70 | v108)) & (v108 ^ v96 & v70) ^ v108 ^ v96 & v70 ^ v83 ^ v96 ^ v70;
  a1[68] = v108 ^ v96 & v70 ^ v83 ^ v96;
  a1[69] = v140;
  a1[70] = v139 ^ v140 ^ v83 ^ (v70 | v108);
  a1[71] = ~v139;
  v15 = __ROR4__(v108 ^ v83 ^ v56 ^ v14 ^ 0x9E3779F1, 21);
  v29 = __ROR4__(v15 ^ v96 ^ v70 ^ v28 ^ 0x9E3779F0, 21);
  v43 = __ROR4__(v29 ^ v108 ^ v83 ^ v42 ^ 0x9E3779F3, 21);
  v57 = __ROR4__(v43 ^ v15 ^ v96 ^ v56 ^ 0x9E3779F2, 21);
  v136 = v57 | v29 & ~v15;
  v134 = v136 ^ v29;
  v137 = ~v15 ^ v136;
  v132 = v134 | ~v15;
  v135 = v29 & ~v15 ^ ~v43 ^ v57 ^ v134;
  v133 = v132 & (v137 | v29 & ~v15 ^ ~v43);
  v138 = v135 ^ v137;
  a1[72] = v133;
  a1[73] = v132 ^ v133 & v138;
  a1[74] = v29 & ~v15 ^ ~v43 ^ v57;
  a1[75] = v138 ^ v133 & v135;
  v71 = __ROR4__(v57 ^ v29 ^ v108 ^ v70 ^ 0x9E3779F5, 21);
  v84 = __ROR4__(v71 ^ v43 ^ v15 ^ v83 ^ 0x9E3779F4, 21);
  v97 = __ROR4__(v84 ^ v57 ^ v29 ^ v96 ^ 0x9E3779F7, 21);
  v109 = __ROR4__(v97 ^ v71 ^ v43 ^ v108 ^ 0x9E3779F6, 21);
  v130 = v71 ^ (v71 ^ v109) & v84;
  v131 = v97 ^ v84 ^ (v71 ^ v109 | v71);
  v128 = v130 | ~(v71 ^ v109 ^ v97 ^ v84);
  v129 = v131 | v97 ^ v71 ^ v109;
  a1[76] = v129 ^ v128 ^ v97 ^ v71 ^ v109 ^ v130;
  a1[77] = v129 ^ v128;
  a1[78] = v71 ^ v109 ^ v97 ^ v84 ^ (v130 | v97);
  a1[79] = v131;
  v16 = __ROR4__(v109 ^ v84 ^ v57 ^ v15 ^ 0x9E3779E9, 21);
  v30 = __ROR4__(v16 ^ v97 ^ v71 ^ v29 ^ 0x9E3779E8, 21);
  v44 = __ROR4__(v30 ^ v109 ^ v84 ^ v43 ^ 0x9E3779EB, 21);
  v58 = __ROR4__(v44 ^ v16 ^ v97 ^ v57 ^ 0x9E3779EA, 21);
  v127 = v58 ^ (v44 | v30) ^ v44 ^ (v58 ^ (v44 | v30) ^ v44 ^ v44 ^ v30 | v16);
  v126 = v58 ^ (v44 | v30) ^ v44 ^ v44 ^ v30 ^ v16 ^ (v58 ^ (v44 | v30) ^ v44 ^ v44 ^ v30 | v58 ^ (v44 | v30));
  a1[80] = (v127 | ~(v126 ^ v58 ^ (v44 | v30) ^ v44)) ^ v58 ^ (v44 | v30) ^ v44 ^ v44 ^ v30;
  a1[81] = v58 ^ (v44 | v30) ^ v16 & (v44 ^ v30 | v58);
  a1[82] = v58 ^ (v44 | v30) ^ v44 ^ v44 ^ v30 ^ v127 & v126;
  a1[83] = v127;
  v72 = __ROR4__(v58 ^ v30 ^ v109 ^ v71 ^ 0x9E3779ED, 21);
  v85 = __ROR4__(v72 ^ v44 ^ v16 ^ v84 ^ 0x9E3779EC, 21);
  v98 = __ROR4__(v85 ^ v58 ^ v30 ^ v97 ^ 0x9E3779EF, 21);
  v110 = __ROR4__(v98 ^ v72 ^ v44 ^ v109 ^ 0x9E3779EE, 21);
  v124 = ~v98 ^ v72 & v110 ^ v85 ^ v110 ^ v72 ^ (v110 | ~v98);
  v125 = v124 ^ (~v98 ^ v72 & v110 | ~v98 ^ v72 & v110 ^ v85 | v110 ^ v72);
  v123 = v125 ^ ~v98 ^ v72 & v110 ^ (~v98 ^ v72 & v110 ^ v85 | v110 ^ v72) ^ v110;
  a1[84] = v125;
  a1[85] = ~v98 ^ v72 & v110 ^ v85;
  a1[86] = v123;
  a1[87] = ~(~v98 ^ v72 & v110) ^ v123 & v124;
  v17 = __ROR4__(v110 ^ v85 ^ v58 ^ v16 ^ 0x9E3779E1, 21);
  v31 = __ROR4__(v17 ^ v98 ^ v72 ^ v30 ^ 0x9E3779E0, 21);
  v45 = __ROR4__(v31 ^ v110 ^ v85 ^ v44 ^ 0x9E3779E3, 21);
  v59 = __ROR4__(v45 ^ v17 ^ v98 ^ v58 ^ 0x9E3779E2, 21);
  v122 = ~v59 ^ v45 ^ (v31 ^ v17) & (v59 ^ v31);
  v121 = v59 ^ v31 | ~v59 ^ v45;
  v120 = v31 ^ v17 ^ v122 & ~v59;
  v119 = v121 ^ v122 ^ ~v59 ^ v59 ^ v31;
  a1[88] = v122;
  a1[89] = v120;
  a1[90] = v119 ^ v120 & (v31 ^ v17);
  a1[91] = (v120 | v119) ^ ~(v31 ^ v17 ^ v121);
  v73 = __ROR4__(v59 ^ v31 ^ v110 ^ v72 ^ 0x9E3779E5, 21);
  v86 = __ROR4__(v73 ^ v45 ^ v17 ^ v85 ^ 0x9E3779E4, 21);
  v99 = __ROR4__(v86 ^ v59 ^ v31 ^ v98 ^ 0x9E3779E7, 21);
  v111 = __ROR4__(v99 ^ v73 ^ v45 ^ v110 ^ 0x9E3779E6, 21);
  v117 = ~v111 ^ v99 ^ (v73 ^ ~v111) & (v111 ^ v86);
  v116 = v73 ^ ~v111 ^ v111 ^ v86 ^ v73 ^ (v73 ^ ~v111 ^ v111 ^ v86) & (~v111 ^ v99);
  v118 = v117 & (v73 ^ ~v111 ^ v111 ^ v86 ^ v73);
  v115 = v118 ^ v73 ^ ~v111;
  a1[92] = v117;
  a1[93] = v115 & v116 ^ v118 ^ (v117 | v73 ^ ~v111 ^ v111 ^ v86);
  a1[94] = ~(v116 ^ (v115 | v118));
  a1[95] = v115;
  v18 = __ROR4__(v111 ^ v86 ^ v59 ^ v17 ^ 0x9E3779D9, 21);
  v32 = __ROR4__(v18 ^ v99 ^ v73 ^ v31 ^ 0x9E3779D8, 21);
  v46 = __ROR4__(v32 ^ v111 ^ v86 ^ v45 ^ 0x9E3779DB, 21);
  v60 = __ROR4__(v46 ^ v18 ^ v99 ^ v59 ^ 0x9E3779DA, 21);
  v113 = (v18 & v32 | v46 ^ v18) ^ (v60 | v18) & (v32 ^ v60);
  v114 = v32 ^ v60 ^ v46 ^ (v18 & v32 ^ (v60 | v18) | v113 ^ v18 & v32);
  a1[96] = v113 ^ v18 & v32 ^ (v60 | v18) ^ (v113 | v114);
  a1[97] = v114;
  a1[98] = v113;
  a1[99] = v32 ^ v60 ^ v46 ^ (v18 & v32 ^ (v60 | v18)) & (v18 & v32 | v46 ^ v18);
  return __readfsqword(0x28u) ^ v207;
}
// 401E2C: using guessed type unsigned __int16 anonymous_1[2];
// 401E2C: using guessed type unsigned __int16 anonymous_3[2];
// 401E2C: using guessed type unsigned __int16 anonymous_5[2];
// 401E2C: using guessed type unsigned __int16 anonymous_6[6];

//----- (000000000040568D) ----------------------------------------------------
__int64 __fastcall decode32le(unsigned __int16 *a1)
{
  return (*((unsigned __int8 *)a1 + 2) << 16) | *a1 | (*((unsigned __int8 *)a1 + 3) << 24);
}

//----- (00000000004056DA) ----------------------------------------------------
unsigned __int64 __fastcall sosemanuk_init(int *a1, _DWORD *a2, const void *a3, size_t a4)
{
  int v4; // eax
  int v5; // et0
  int v6; // et0
  int v7; // et0
  int v8; // et0
  int v9; // et0
  int v10; // et0
  int v11; // et0
  int v12; // et0
  int v13; // et0
  int v14; // et0
  int v15; // et0
  int v16; // et0
  int v17; // et0
  int v18; // et0
  int v20; // [rsp+Ch] [rbp-54h]
  int v21; // [rsp+Ch] [rbp-54h]
  int v22; // [rsp+Ch] [rbp-54h]
  int v23; // [rsp+Ch] [rbp-54h]
  int v24; // [rsp+Ch] [rbp-54h]
  int v25; // [rsp+Ch] [rbp-54h]
  int v26; // [rsp+Ch] [rbp-54h]
  int v27; // [rsp+Ch] [rbp-54h]
  int v28; // [rsp+Ch] [rbp-54h]
  int v29; // [rsp+Ch] [rbp-54h]
  int v30; // [rsp+Ch] [rbp-54h]
  int v31; // [rsp+Ch] [rbp-54h]
  int v32; // [rsp+Ch] [rbp-54h]
  int v33; // [rsp+Ch] [rbp-54h]
  int v34; // [rsp+Ch] [rbp-54h]
  int v35; // [rsp+Ch] [rbp-54h]
  int v36; // [rsp+Ch] [rbp-54h]
  int v37; // [rsp+Ch] [rbp-54h]
  int v38; // [rsp+Ch] [rbp-54h]
  int v39; // [rsp+Ch] [rbp-54h]
  int v40; // [rsp+Ch] [rbp-54h]
  int v41; // [rsp+Ch] [rbp-54h]
  int v42; // [rsp+Ch] [rbp-54h]
  int v43; // [rsp+Ch] [rbp-54h]
  int v44; // [rsp+Ch] [rbp-54h]
  int v45; // [rsp+Ch] [rbp-54h]
  int v46; // [rsp+Ch] [rbp-54h]
  int v47; // [rsp+Ch] [rbp-54h]
  int v48; // [rsp+Ch] [rbp-54h]
  int v49; // [rsp+Ch] [rbp-54h]
  int v50; // [rsp+Ch] [rbp-54h]
  int v51; // [rsp+Ch] [rbp-54h]
  int v52; // [rsp+Ch] [rbp-54h]
  int v53; // [rsp+Ch] [rbp-54h]
  int v54; // [rsp+Ch] [rbp-54h]
  int v55; // [rsp+Ch] [rbp-54h]
  int v56; // [rsp+Ch] [rbp-54h]
  int v57; // [rsp+Ch] [rbp-54h]
  int v58; // [rsp+Ch] [rbp-54h]
  int v59; // [rsp+Ch] [rbp-54h]
  int v60; // [rsp+Ch] [rbp-54h]
  int v61; // [rsp+Ch] [rbp-54h]
  int v62; // [rsp+Ch] [rbp-54h]
  int v63; // [rsp+Ch] [rbp-54h]
  int v64; // [rsp+Ch] [rbp-54h]
  int v65; // [rsp+Ch] [rbp-54h]
  int v66; // [rsp+Ch] [rbp-54h]
  int v67; // [rsp+Ch] [rbp-54h]
  int v68; // [rsp+Ch] [rbp-54h]
  int v69; // [rsp+Ch] [rbp-54h]
  int v70; // [rsp+Ch] [rbp-54h]
  int v71; // [rsp+Ch] [rbp-54h]
  int v72; // [rsp+Ch] [rbp-54h]
  int v73; // [rsp+Ch] [rbp-54h]
  int v74; // [rsp+Ch] [rbp-54h]
  int v75; // [rsp+Ch] [rbp-54h]
  int v76; // [rsp+Ch] [rbp-54h]
  int v77; // [rsp+Ch] [rbp-54h]
  int v78; // [rsp+Ch] [rbp-54h]
  int v79; // [rsp+Ch] [rbp-54h]
  int v80; // [rsp+Ch] [rbp-54h]
  int v81; // [rsp+Ch] [rbp-54h]
  int v82; // [rsp+Ch] [rbp-54h]
  int v83; // [rsp+Ch] [rbp-54h]
  int v84; // [rsp+Ch] [rbp-54h]
  int v85; // [rsp+Ch] [rbp-54h]
  int v86; // [rsp+Ch] [rbp-54h]
  int v87; // [rsp+Ch] [rbp-54h]
  int v88; // [rsp+Ch] [rbp-54h]
  int v89; // [rsp+Ch] [rbp-54h]
  int v90; // [rsp+Ch] [rbp-54h]
  int v91; // [rsp+Ch] [rbp-54h]
  int v92; // [rsp+Ch] [rbp-54h]
  int v93; // [rsp+Ch] [rbp-54h]
  int v94; // [rsp+Ch] [rbp-54h]
  int v95; // [rsp+Ch] [rbp-54h]
  int v96; // [rsp+Ch] [rbp-54h]
  int v97; // [rsp+Ch] [rbp-54h]
  int v98; // [rsp+Ch] [rbp-54h]
  int v99; // [rsp+Ch] [rbp-54h]
  int v100; // [rsp+Ch] [rbp-54h]
  int v101; // [rsp+Ch] [rbp-54h]
  int v102; // [rsp+Ch] [rbp-54h]
  int v103; // [rsp+Ch] [rbp-54h]
  int v104; // [rsp+Ch] [rbp-54h]
  int v105; // [rsp+Ch] [rbp-54h]
  int v106; // [rsp+Ch] [rbp-54h]
  int v107; // [rsp+10h] [rbp-50h]
  int v108; // [rsp+10h] [rbp-50h]
  int v109; // [rsp+10h] [rbp-50h]
  int v110; // [rsp+10h] [rbp-50h]
  int v111; // [rsp+10h] [rbp-50h]
  int v112; // [rsp+10h] [rbp-50h]
  int v113; // [rsp+10h] [rbp-50h]
  int v114; // [rsp+10h] [rbp-50h]
  int v115; // [rsp+10h] [rbp-50h]
  int v116; // [rsp+10h] [rbp-50h]
  int v117; // [rsp+10h] [rbp-50h]
  int v118; // [rsp+10h] [rbp-50h]
  int v119; // [rsp+10h] [rbp-50h]
  int v120; // [rsp+10h] [rbp-50h]
  int v121; // [rsp+10h] [rbp-50h]
  int v122; // [rsp+10h] [rbp-50h]
  int v123; // [rsp+10h] [rbp-50h]
  int v124; // [rsp+10h] [rbp-50h]
  int v125; // [rsp+10h] [rbp-50h]
  int v126; // [rsp+10h] [rbp-50h]
  int v127; // [rsp+10h] [rbp-50h]
  int v128; // [rsp+10h] [rbp-50h]
  int v129; // [rsp+10h] [rbp-50h]
  int v130; // [rsp+10h] [rbp-50h]
  int v131; // [rsp+10h] [rbp-50h]
  int v132; // [rsp+10h] [rbp-50h]
  int v133; // [rsp+10h] [rbp-50h]
  int v134; // [rsp+10h] [rbp-50h]
  int v135; // [rsp+10h] [rbp-50h]
  int v136; // [rsp+10h] [rbp-50h]
  int v137; // [rsp+10h] [rbp-50h]
  int v138; // [rsp+10h] [rbp-50h]
  int v139; // [rsp+10h] [rbp-50h]
  int v140; // [rsp+10h] [rbp-50h]
  int v141; // [rsp+10h] [rbp-50h]
  int v142; // [rsp+10h] [rbp-50h]
  int v143; // [rsp+10h] [rbp-50h]
  int v144; // [rsp+10h] [rbp-50h]
  int v145; // [rsp+10h] [rbp-50h]
  int v146; // [rsp+10h] [rbp-50h]
  int v147; // [rsp+10h] [rbp-50h]
  int v148; // [rsp+10h] [rbp-50h]
  int v149; // [rsp+10h] [rbp-50h]
  int v150; // [rsp+10h] [rbp-50h]
  int v151; // [rsp+10h] [rbp-50h]
  int v152; // [rsp+10h] [rbp-50h]
  int v153; // [rsp+10h] [rbp-50h]
  int v154; // [rsp+10h] [rbp-50h]
  int v155; // [rsp+10h] [rbp-50h]
  int v156; // [rsp+10h] [rbp-50h]
  int v157; // [rsp+10h] [rbp-50h]
  int v158; // [rsp+10h] [rbp-50h]
  int v159; // [rsp+10h] [rbp-50h]
  int v160; // [rsp+10h] [rbp-50h]
  int v161; // [rsp+10h] [rbp-50h]
  int v162; // [rsp+10h] [rbp-50h]
  int v163; // [rsp+10h] [rbp-50h]
  int v164; // [rsp+10h] [rbp-50h]
  int v165; // [rsp+10h] [rbp-50h]
  int v166; // [rsp+10h] [rbp-50h]
  int v167; // [rsp+10h] [rbp-50h]
  int v168; // [rsp+10h] [rbp-50h]
  int v169; // [rsp+10h] [rbp-50h]
  int v170; // [rsp+10h] [rbp-50h]
  int v171; // [rsp+10h] [rbp-50h]
  int v172; // [rsp+10h] [rbp-50h]
  int v173; // [rsp+10h] [rbp-50h]
  int v174; // [rsp+10h] [rbp-50h]
  int v175; // [rsp+10h] [rbp-50h]
  int v176; // [rsp+10h] [rbp-50h]
  int v177; // [rsp+10h] [rbp-50h]
  int v178; // [rsp+10h] [rbp-50h]
  int v179; // [rsp+10h] [rbp-50h]
  int v180; // [rsp+10h] [rbp-50h]
  int v181; // [rsp+10h] [rbp-50h]
  int v182; // [rsp+10h] [rbp-50h]
  int v183; // [rsp+10h] [rbp-50h]
  int v184; // [rsp+10h] [rbp-50h]
  int v185; // [rsp+10h] [rbp-50h]
  int v186; // [rsp+10h] [rbp-50h]
  int v187; // [rsp+10h] [rbp-50h]
  int v188; // [rsp+10h] [rbp-50h]
  int v189; // [rsp+10h] [rbp-50h]
  int v190; // [rsp+10h] [rbp-50h]
  int v191; // [rsp+10h] [rbp-50h]
  int v192; // [rsp+10h] [rbp-50h]
  int v193; // [rsp+10h] [rbp-50h]
  int v194; // [rsp+10h] [rbp-50h]
  int v195; // [rsp+10h] [rbp-50h]
  int v196; // [rsp+10h] [rbp-50h]
  int v197; // [rsp+10h] [rbp-50h]
  int v198; // [rsp+10h] [rbp-50h]
  int v199; // [rsp+10h] [rbp-50h]
  int v200; // [rsp+10h] [rbp-50h]
  int v201; // [rsp+10h] [rbp-50h]
  int v202; // [rsp+10h] [rbp-50h]
  int v203; // [rsp+10h] [rbp-50h]
  int v204; // [rsp+10h] [rbp-50h]
  int v205; // [rsp+10h] [rbp-50h]
  int v206; // [rsp+10h] [rbp-50h]
  int v207; // [rsp+10h] [rbp-50h]
  int v208; // [rsp+14h] [rbp-4Ch]
  int v209; // [rsp+14h] [rbp-4Ch]
  int v210; // [rsp+14h] [rbp-4Ch]
  int v211; // [rsp+14h] [rbp-4Ch]
  int v212; // [rsp+14h] [rbp-4Ch]
  int v213; // [rsp+14h] [rbp-4Ch]
  int v214; // [rsp+14h] [rbp-4Ch]
  int v215; // [rsp+14h] [rbp-4Ch]
  int v216; // [rsp+14h] [rbp-4Ch]
  int v217; // [rsp+14h] [rbp-4Ch]
  int v218; // [rsp+14h] [rbp-4Ch]
  int v219; // [rsp+14h] [rbp-4Ch]
  int v220; // [rsp+14h] [rbp-4Ch]
  int v221; // [rsp+14h] [rbp-4Ch]
  int v222; // [rsp+14h] [rbp-4Ch]
  int v223; // [rsp+14h] [rbp-4Ch]
  int v224; // [rsp+14h] [rbp-4Ch]
  int v225; // [rsp+14h] [rbp-4Ch]
  int v226; // [rsp+14h] [rbp-4Ch]
  int v227; // [rsp+14h] [rbp-4Ch]
  int v228; // [rsp+14h] [rbp-4Ch]
  int v229; // [rsp+14h] [rbp-4Ch]
  int v230; // [rsp+14h] [rbp-4Ch]
  int v231; // [rsp+14h] [rbp-4Ch]
  int v232; // [rsp+14h] [rbp-4Ch]
  int v233; // [rsp+14h] [rbp-4Ch]
  int v234; // [rsp+14h] [rbp-4Ch]
  int v235; // [rsp+14h] [rbp-4Ch]
  int v236; // [rsp+14h] [rbp-4Ch]
  int v237; // [rsp+14h] [rbp-4Ch]
  int v238; // [rsp+14h] [rbp-4Ch]
  int v239; // [rsp+14h] [rbp-4Ch]
  int v240; // [rsp+14h] [rbp-4Ch]
  int v241; // [rsp+14h] [rbp-4Ch]
  int v242; // [rsp+14h] [rbp-4Ch]
  int v243; // [rsp+14h] [rbp-4Ch]
  int v244; // [rsp+14h] [rbp-4Ch]
  int v245; // [rsp+14h] [rbp-4Ch]
  int v246; // [rsp+14h] [rbp-4Ch]
  int v247; // [rsp+14h] [rbp-4Ch]
  int v248; // [rsp+14h] [rbp-4Ch]
  int v249; // [rsp+14h] [rbp-4Ch]
  int v250; // [rsp+14h] [rbp-4Ch]
  int v251; // [rsp+14h] [rbp-4Ch]
  int v252; // [rsp+14h] [rbp-4Ch]
  int v253; // [rsp+14h] [rbp-4Ch]
  int v254; // [rsp+14h] [rbp-4Ch]
  int v255; // [rsp+14h] [rbp-4Ch]
  int v256; // [rsp+14h] [rbp-4Ch]
  int v257; // [rsp+14h] [rbp-4Ch]
  int v258; // [rsp+14h] [rbp-4Ch]
  int v259; // [rsp+14h] [rbp-4Ch]
  int v260; // [rsp+14h] [rbp-4Ch]
  int v261; // [rsp+14h] [rbp-4Ch]
  int v262; // [rsp+14h] [rbp-4Ch]
  int v263; // [rsp+14h] [rbp-4Ch]
  int v264; // [rsp+14h] [rbp-4Ch]
  int v265; // [rsp+14h] [rbp-4Ch]
  int v266; // [rsp+14h] [rbp-4Ch]
  int v267; // [rsp+14h] [rbp-4Ch]
  int v268; // [rsp+14h] [rbp-4Ch]
  int v269; // [rsp+14h] [rbp-4Ch]
  int v270; // [rsp+14h] [rbp-4Ch]
  int v271; // [rsp+14h] [rbp-4Ch]
  int v272; // [rsp+14h] [rbp-4Ch]
  int v273; // [rsp+14h] [rbp-4Ch]
  int v274; // [rsp+14h] [rbp-4Ch]
  int v275; // [rsp+14h] [rbp-4Ch]
  int v276; // [rsp+14h] [rbp-4Ch]
  int v277; // [rsp+14h] [rbp-4Ch]
  int v278; // [rsp+14h] [rbp-4Ch]
  int v279; // [rsp+14h] [rbp-4Ch]
  int v280; // [rsp+14h] [rbp-4Ch]
  int v281; // [rsp+14h] [rbp-4Ch]
  int v282; // [rsp+14h] [rbp-4Ch]
  int v283; // [rsp+14h] [rbp-4Ch]
  int v284; // [rsp+14h] [rbp-4Ch]
  int v285; // [rsp+14h] [rbp-4Ch]
  int v286; // [rsp+14h] [rbp-4Ch]
  int v287; // [rsp+14h] [rbp-4Ch]
  int v288; // [rsp+14h] [rbp-4Ch]
  int v289; // [rsp+14h] [rbp-4Ch]
  int v290; // [rsp+14h] [rbp-4Ch]
  int v291; // [rsp+14h] [rbp-4Ch]
  int v292; // [rsp+14h] [rbp-4Ch]
  int v293; // [rsp+14h] [rbp-4Ch]
  int v294; // [rsp+14h] [rbp-4Ch]
  int v295; // [rsp+14h] [rbp-4Ch]
  int v296; // [rsp+14h] [rbp-4Ch]
  int v297; // [rsp+18h] [rbp-48h]
  int v298; // [rsp+18h] [rbp-48h]
  int v299; // [rsp+18h] [rbp-48h]
  int v300; // [rsp+18h] [rbp-48h]
  int v301; // [rsp+18h] [rbp-48h]
  int v302; // [rsp+18h] [rbp-48h]
  int v303; // [rsp+18h] [rbp-48h]
  int v304; // [rsp+18h] [rbp-48h]
  int v305; // [rsp+18h] [rbp-48h]
  int v306; // [rsp+18h] [rbp-48h]
  int v307; // [rsp+18h] [rbp-48h]
  int v308; // [rsp+18h] [rbp-48h]
  int v309; // [rsp+18h] [rbp-48h]
  int v310; // [rsp+18h] [rbp-48h]
  int v311; // [rsp+18h] [rbp-48h]
  int v312; // [rsp+18h] [rbp-48h]
  int v313; // [rsp+18h] [rbp-48h]
  int v314; // [rsp+18h] [rbp-48h]
  int v315; // [rsp+18h] [rbp-48h]
  int v316; // [rsp+18h] [rbp-48h]
  int v317; // [rsp+18h] [rbp-48h]
  int v318; // [rsp+18h] [rbp-48h]
  int v319; // [rsp+18h] [rbp-48h]
  int v320; // [rsp+18h] [rbp-48h]
  int v321; // [rsp+18h] [rbp-48h]
  int v322; // [rsp+18h] [rbp-48h]
  int v323; // [rsp+18h] [rbp-48h]
  int v324; // [rsp+18h] [rbp-48h]
  int v325; // [rsp+18h] [rbp-48h]
  int v326; // [rsp+18h] [rbp-48h]
  int v327; // [rsp+18h] [rbp-48h]
  int v328; // [rsp+18h] [rbp-48h]
  int v329; // [rsp+18h] [rbp-48h]
  int v330; // [rsp+18h] [rbp-48h]
  int v331; // [rsp+18h] [rbp-48h]
  int v332; // [rsp+18h] [rbp-48h]
  int v333; // [rsp+18h] [rbp-48h]
  int v334; // [rsp+18h] [rbp-48h]
  int v335; // [rsp+18h] [rbp-48h]
  int v336; // [rsp+18h] [rbp-48h]
  int v337; // [rsp+18h] [rbp-48h]
  int v338; // [rsp+18h] [rbp-48h]
  int v339; // [rsp+18h] [rbp-48h]
  int v340; // [rsp+18h] [rbp-48h]
  int v341; // [rsp+18h] [rbp-48h]
  int v342; // [rsp+18h] [rbp-48h]
  int v343; // [rsp+18h] [rbp-48h]
  int v344; // [rsp+18h] [rbp-48h]
  int v345; // [rsp+18h] [rbp-48h]
  int v346; // [rsp+18h] [rbp-48h]
  int v347; // [rsp+18h] [rbp-48h]
  int v348; // [rsp+18h] [rbp-48h]
  int v349; // [rsp+18h] [rbp-48h]
  int v350; // [rsp+18h] [rbp-48h]
  int v351; // [rsp+18h] [rbp-48h]
  int v352; // [rsp+18h] [rbp-48h]
  int v353; // [rsp+18h] [rbp-48h]
  int v354; // [rsp+18h] [rbp-48h]
  int v355; // [rsp+18h] [rbp-48h]
  int v356; // [rsp+18h] [rbp-48h]
  int v357; // [rsp+18h] [rbp-48h]
  int v358; // [rsp+18h] [rbp-48h]
  int v359; // [rsp+18h] [rbp-48h]
  int v360; // [rsp+18h] [rbp-48h]
  int v361; // [rsp+18h] [rbp-48h]
  int v362; // [rsp+18h] [rbp-48h]
  int v363; // [rsp+18h] [rbp-48h]
  int v364; // [rsp+18h] [rbp-48h]
  int v365; // [rsp+18h] [rbp-48h]
  int v366; // [rsp+18h] [rbp-48h]
  int v367; // [rsp+18h] [rbp-48h]
  int v368; // [rsp+18h] [rbp-48h]
  int v369; // [rsp+18h] [rbp-48h]
  int v370; // [rsp+18h] [rbp-48h]
  int v371; // [rsp+18h] [rbp-48h]
  int v372; // [rsp+18h] [rbp-48h]
  int v373; // [rsp+18h] [rbp-48h]
  int v374; // [rsp+18h] [rbp-48h]
  int v375; // [rsp+18h] [rbp-48h]
  int v376; // [rsp+18h] [rbp-48h]
  int v377; // [rsp+18h] [rbp-48h]
  int v378; // [rsp+18h] [rbp-48h]
  int v379; // [rsp+18h] [rbp-48h]
  int v380; // [rsp+18h] [rbp-48h]
  int v381; // [rsp+18h] [rbp-48h]
  int v382; // [rsp+18h] [rbp-48h]
  int v383; // [rsp+18h] [rbp-48h]
  int v384; // [rsp+1Ch] [rbp-44h]
  int v385; // [rsp+1Ch] [rbp-44h]
  int v386; // [rsp+1Ch] [rbp-44h]
  int v387; // [rsp+1Ch] [rbp-44h]
  int v388; // [rsp+1Ch] [rbp-44h]
  int v389; // [rsp+1Ch] [rbp-44h]
  int v390; // [rsp+1Ch] [rbp-44h]
  int v391; // [rsp+1Ch] [rbp-44h]
  int v392; // [rsp+1Ch] [rbp-44h]
  int v393; // [rsp+1Ch] [rbp-44h]
  int v394; // [rsp+1Ch] [rbp-44h]
  int v395; // [rsp+1Ch] [rbp-44h]
  int v396; // [rsp+1Ch] [rbp-44h]
  int v397; // [rsp+1Ch] [rbp-44h]
  int v398; // [rsp+1Ch] [rbp-44h]
  int v399; // [rsp+1Ch] [rbp-44h]
  int v400; // [rsp+1Ch] [rbp-44h]
  int v401; // [rsp+1Ch] [rbp-44h]
  int v402; // [rsp+1Ch] [rbp-44h]
  int v403; // [rsp+1Ch] [rbp-44h]
  int v404; // [rsp+1Ch] [rbp-44h]
  int v405; // [rsp+1Ch] [rbp-44h]
  int v406; // [rsp+1Ch] [rbp-44h]
  int v407; // [rsp+1Ch] [rbp-44h]
  int v408; // [rsp+1Ch] [rbp-44h]
  int v409; // [rsp+1Ch] [rbp-44h]
  int v410; // [rsp+1Ch] [rbp-44h]
  int v411; // [rsp+1Ch] [rbp-44h]
  int v412; // [rsp+1Ch] [rbp-44h]
  int v413; // [rsp+1Ch] [rbp-44h]
  int v414; // [rsp+1Ch] [rbp-44h]
  int v415; // [rsp+1Ch] [rbp-44h]
  int v416; // [rsp+1Ch] [rbp-44h]
  int v417; // [rsp+1Ch] [rbp-44h]
  int v418; // [rsp+1Ch] [rbp-44h]
  int v419; // [rsp+1Ch] [rbp-44h]
  int v420; // [rsp+1Ch] [rbp-44h]
  int v421; // [rsp+1Ch] [rbp-44h]
  int v422; // [rsp+1Ch] [rbp-44h]
  int v423; // [rsp+1Ch] [rbp-44h]
  int v424; // [rsp+1Ch] [rbp-44h]
  int v425; // [rsp+1Ch] [rbp-44h]
  int v426; // [rsp+1Ch] [rbp-44h]
  int v427; // [rsp+1Ch] [rbp-44h]
  int v428; // [rsp+1Ch] [rbp-44h]
  int v429; // [rsp+1Ch] [rbp-44h]
  int v430; // [rsp+1Ch] [rbp-44h]
  int v431; // [rsp+1Ch] [rbp-44h]
  int v432; // [rsp+1Ch] [rbp-44h]
  int v433; // [rsp+1Ch] [rbp-44h]
  int v434; // [rsp+1Ch] [rbp-44h]
  int v435; // [rsp+1Ch] [rbp-44h]
  int v436; // [rsp+1Ch] [rbp-44h]
  int v437; // [rsp+1Ch] [rbp-44h]
  int v438; // [rsp+1Ch] [rbp-44h]
  int v439; // [rsp+1Ch] [rbp-44h]
  int v440; // [rsp+1Ch] [rbp-44h]
  int v441; // [rsp+1Ch] [rbp-44h]
  int v442; // [rsp+1Ch] [rbp-44h]
  int v443; // [rsp+1Ch] [rbp-44h]
  int v444; // [rsp+1Ch] [rbp-44h]
  int v445; // [rsp+1Ch] [rbp-44h]
  int v446; // [rsp+1Ch] [rbp-44h]
  int v447; // [rsp+1Ch] [rbp-44h]
  int v448; // [rsp+1Ch] [rbp-44h]
  int v449; // [rsp+1Ch] [rbp-44h]
  int v450; // [rsp+1Ch] [rbp-44h]
  int v451; // [rsp+1Ch] [rbp-44h]
  int v452; // [rsp+1Ch] [rbp-44h]
  int v453; // [rsp+1Ch] [rbp-44h]
  int v454; // [rsp+1Ch] [rbp-44h]
  int v455; // [rsp+1Ch] [rbp-44h]
  int v456; // [rsp+1Ch] [rbp-44h]
  int v457; // [rsp+1Ch] [rbp-44h]
  int v458; // [rsp+1Ch] [rbp-44h]
  int v459; // [rsp+1Ch] [rbp-44h]
  int v460; // [rsp+1Ch] [rbp-44h]
  int v461; // [rsp+1Ch] [rbp-44h]
  int v462; // [rsp+1Ch] [rbp-44h]
  int v463; // [rsp+1Ch] [rbp-44h]
  int v464; // [rsp+1Ch] [rbp-44h]
  int v465; // [rsp+1Ch] [rbp-44h]
  int v466; // [rsp+1Ch] [rbp-44h]
  int v467; // [rsp+1Ch] [rbp-44h]
  unsigned __int16 dest[2]; // [rsp+40h] [rbp-20h] BYREF
  unsigned __int16 v470; // [rsp+44h] [rbp-1Ch] BYREF
  unsigned __int16 v471[2]; // [rsp+48h] [rbp-18h] BYREF
  unsigned __int16 v472[6]; // [rsp+4Ch] [rbp-14h] BYREF
  unsigned __int64 v473; // [rsp+58h] [rbp-8h]

  v473 = __readfsqword(0x28u);
  if ( a4 <= 0xF )
  {
    if ( a4 )
      memcpy(dest, a3, a4);
    memset((char *)dest + a4, 0, 16 - a4);
  }
  else
  {
    memcpy(dest, a3, 0x10uLL);
  }
  v20 = decode32le(dest);
  v107 = decode32le(&v470);
  v208 = decode32le(v471);
  v4 = decode32le(v472);
  v21 = *a2 ^ v20;
  v209 = a2[2] ^ v208;
  v297 = v21 ^ a2[3] ^ v4;
  v384 = a2[1] ^ v107;
  v108 = v297 & v384;
  v385 = v209 ^ v384;
  v109 = v21 ^ v108;
  v22 = v385 ^ (v297 | v21);
  v386 = v297 ^ v385;
  v298 = v209 ^ v297;
  v210 = v386 ^ (v109 | v209);
  v387 = v109 | ~v386;
  v110 = v387 ^ v298 ^ v109;
  v299 = v22 | v298;
  v111 = __ROR4__(v299 ^ v110, 19);
  v211 = __ROR4__(v210, 29);
  v388 = __ROR4__(v111 ^ v299 ^ v387 ^ v211, 31);
  v23 = __ROR4__((8 * v111) ^ v211 ^ v22, 25);
  v5 = __ROR4__((v388 << 7) ^ v23 ^ v211, 10);
  v112 = a2[4] ^ __ROR4__(v388 ^ v111 ^ v23, 27);
  v389 = a2[5] ^ v388;
  v24 = a2[7] ^ v23;
  v300 = ~v112;
  v113 = v389 & ~v112;
  v212 = v113 ^ ~(a2[6] ^ v5);
  v114 = v24 | v113;
  v25 = v212 ^ v24;
  v390 = v114 ^ v389;
  v115 = v300 ^ v114;
  v301 = v390 | v300;
  v391 = v25 ^ v390;
  v213 = v301 & (v115 | v212);
  v116 = v391 ^ v115;
  v392 = v116 ^ v213 & v391;
  v117 = v301 ^ v213 & v116;
  v214 = __ROR4__(v213, 19);
  v26 = __ROR4__(v25, 29);
  v118 = __ROR4__(v214 ^ v117 ^ v26, 31);
  v393 = __ROR4__((8 * v214) ^ v26 ^ v392, 25);
  v6 = __ROR4__((v118 << 7) ^ v393 ^ v26, 10);
  v215 = a2[8] ^ __ROR4__(v118 ^ v214 ^ v393, 27);
  v119 = a2[9] ^ v118;
  v27 = a2[10] ^ v6;
  v394 = a2[11] ^ v393;
  v302 = v215;
  v216 = v394 ^ v27 & v215;
  v28 = v216 ^ v119 ^ v27;
  v395 = v119 ^ (v302 | v394);
  v303 = v28 ^ v302;
  v120 = v395;
  v396 = v216 ^ (v303 | v395);
  v304 = v120 & v216 ^ v303;
  v29 = __ROR4__(v28, 19);
  v121 = __ROR4__(v304 ^ v396 ^ v120, 29);
  v397 = __ROR4__(v29 ^ v396 ^ v121, 31);
  v305 = __ROR4__((8 * v29) ^ v121 ^ ~v304, 25);
  v7 = __ROR4__((v397 << 7) ^ v305 ^ v121, 10);
  v30 = a2[12] ^ __ROR4__(v397 ^ v29 ^ v305, 27);
  v398 = a2[13] ^ v397;
  v122 = a2[14] ^ v7;
  v306 = a2[15] ^ v305;
  v217 = v30;
  v31 = v306 | v30;
  v307 = v398 ^ v306;
  v399 = v217 & v398;
  v218 = v122 ^ v217;
  v123 = v307 ^ v122;
  v219 = v399 | v218;
  v308 = v219 ^ v31 & v307;
  v32 = v399 ^ v31;
  v220 = v123 ^ v32 & v219;
  v124 = v123 ^ (v32 | v308 ^ v399);
  v400 = __ROR4__(v308 ^ v32 ^ (v308 | v124), 19);
  v309 = __ROR4__(v308, 29);
  v125 = __ROR4__(v400 ^ v124 ^ v309, 31);
  v221 = __ROR4__((8 * v400) ^ v309 ^ v220, 25);
  v8 = __ROR4__((v125 << 7) ^ v221 ^ v309, 10);
  v401 = a2[16] ^ __ROR4__(v125 ^ v400 ^ v221, 27);
  v222 = a2[19] ^ v221;
  v126 = v222 ^ a2[17] ^ v125;
  v223 = ~v222;
  v310 = v223 ^ a2[18] ^ v8;
  v224 = v401 ^ v223;
  v33 = v126;
  v127 = v310 ^ v224 & v126;
  v34 = v224 ^ v33;
  v402 = v34 ^ v401;
  v311 = v402 ^ v34 & v310;
  v403 = v127 & v402;
  v225 = v403 ^ v224;
  v35 = v403 ^ (v127 | v34);
  v128 = __ROR4__(v127, 19);
  v404 = __ROR4__(~(v311 ^ (v225 | v403)), 29);
  v36 = __ROR4__(v128 ^ v225 & v311 ^ v35 ^ v404, 31);
  v226 = __ROR4__((8 * v128) ^ v404 ^ v225, 25);
  v9 = __ROR4__((v36 << 7) ^ v226 ^ v404, 10);
  v129 = a2[20] ^ __ROR4__(v36 ^ v128 ^ v226, 27);
  v37 = a2[21] ^ v36;
  v227 = a2[23] ^ v226;
  v130 = v37 ^ v129;
  v38 = v227 ^ v37;
  v228 = ~v227;
  v312 = v38;
  v405 = v228 ^ a2[22] ^ v9;
  v39 = v405 ^ v130 & v38;
  v406 = v312 | v405;
  v313 = v228 ^ v312;
  v229 = v130 ^ v39 & v228;
  v314 = v406 ^ v39 ^ v313;
  v407 = (v229 | v314) ^ ~(v130 ^ v406);
  v40 = __ROR4__(v39, 19);
  v131 = __ROR4__(v314 ^ v229 & v130, 29);
  v230 = __ROR4__(v40 ^ v229 ^ v131, 31);
  v408 = __ROR4__((8 * v40) ^ v131 ^ v407, 25);
  v41 = a2[24] ^ __ROR4__(v230 ^ v40 ^ v408, 27);
  v132 = ~(a2[26] ^ __ROR4__((v230 << 7) ^ v408 ^ v131, 10));
  v315 = a2[27] ^ v408;
  v409 = v41 & v315;
  v42 = v315 ^ v41;
  v410 = v132 ^ v409;
  v231 = v410 ^ a2[25] ^ v230;
  v133 = v42 ^ (v315 | v132);
  v43 = v231 | v42;
  v134 = v231 ^ v133;
  v316 = v43 ^ v315;
  v44 = v134 ^ (v410 | v43);
  v317 = v44 ^ v410 ^ v316;
  v135 = ~v410 ^ v317 & v134;
  v45 = __ROR4__(v44, 19);
  v318 = __ROR4__(v317, 29);
  v232 = __ROR4__(v45 ^ v231 ^ v318, 31);
  v136 = __ROR4__((8 * v45) ^ v318 ^ v135, 25);
  v46 = a2[28] ^ __ROR4__(v232 ^ v45 ^ v136, 27);
  v319 = a2[30] ^ __ROR4__((v232 << 7) ^ v136 ^ v318, 10);
  v137 = a2[31] ^ v136;
  v411 = a2[29] ^ v232;
  v233 = v137 ^ (v319 | v411);
  v412 = v319 ^ v411;
  v320 = v233 ^ v319;
  v138 = v46 & (v412 | v137);
  v413 = v320 ^ v412;
  v139 = v233 ^ v138;
  v234 = v46 ^ (v413 | v233);
  v47 = v320 ^ (v413 | v46);
  v235 = v413 ^ v234;
  v321 = v235 ^ v320;
  v236 = v413 ^ v47 & v235;
  v414 = __ROR4__((v47 | ~v321) ^ v413, 19);
  v237 = __ROR4__(v236, 29);
  v140 = __ROR4__(v414 ^ v139 ^ v237, 31);
  v48 = __ROR4__((8 * v414) ^ v237 ^ v47, 25);
  v415 = a2[32] ^ __ROR4__(v140 ^ v414 ^ v48, 27);
  v238 = a2[34] ^ __ROR4__((v140 << 7) ^ v48 ^ v237, 10);
  v49 = v415 ^ a2[35] ^ v48;
  v322 = a2[33] ^ v140;
  v141 = v49 & v322;
  v323 = v238 ^ v322;
  v142 = v415 ^ v141;
  v416 = v323 ^ (v49 | v415);
  v324 = v49 ^ v323;
  v50 = v238 ^ v49;
  v239 = v324 ^ (v142 | v238);
  v325 = v142 | ~v324;
  v143 = v325 ^ v50 ^ v142;
  v51 = v416 | v50;
  v144 = __ROR4__(v51 ^ v143, 19);
  v240 = __ROR4__(v239, 29);
  v326 = __ROR4__(v144 ^ v51 ^ v325 ^ v240, 31);
  v417 = __ROR4__((8 * v144) ^ v240 ^ v416, 25);
  v10 = __ROR4__((v326 << 7) ^ v417 ^ v240, 10);
  v145 = a2[36] ^ __ROR4__(v326 ^ v144 ^ v417, 27);
  v327 = a2[37] ^ v326;
  v418 = a2[39] ^ v417;
  v52 = ~v145;
  v146 = v327 & ~v145;
  v241 = v146 ^ ~(a2[38] ^ v10);
  v147 = v418 | v146;
  v419 = v241 ^ v418;
  v328 = v147 ^ v327;
  v148 = v52 ^ v147;
  v53 = v328 | v52;
  v329 = v419 ^ v328;
  v242 = v53 & (v148 | v241);
  v149 = v329 ^ v148;
  v330 = v149 ^ v242 & v329;
  v150 = v53 ^ v242 & v149;
  v243 = __ROR4__(v242, 19);
  v420 = __ROR4__(v419, 29);
  v151 = __ROR4__(v243 ^ v150 ^ v420, 31);
  v331 = __ROR4__((8 * v243) ^ v420 ^ v330, 25);
  v11 = __ROR4__((v151 << 7) ^ v331 ^ v420, 10);
  v244 = a2[40] ^ __ROR4__(v151 ^ v243 ^ v331, 27);
  v152 = a2[41] ^ v151;
  v421 = a2[42] ^ v11;
  v332 = a2[43] ^ v331;
  v54 = v244;
  v245 = v332 ^ v421 & v244;
  v422 = v245 ^ v152 ^ v421;
  v333 = v152 ^ (v54 | v332);
  v55 = v422 ^ v54;
  v153 = v333;
  v334 = v245 ^ (v55 | v333);
  v56 = v153 & v245 ^ v55;
  v423 = __ROR4__(v422, 19);
  v154 = __ROR4__(v56 ^ v334 ^ v153, 29);
  v335 = __ROR4__(v423 ^ v334 ^ v154, 31);
  v57 = __ROR4__((8 * v423) ^ v154 ^ ~v56, 25);
  v12 = __ROR4__((v335 << 7) ^ v57 ^ v154, 10);
  v424 = a2[44] ^ __ROR4__(v335 ^ v423 ^ v57, 27);
  v336 = a2[45] ^ v335;
  v155 = a2[46] ^ v12;
  v58 = a2[47] ^ v57;
  v246 = v424;
  v425 = v58 | v424;
  v59 = v336 ^ v58;
  v337 = v246 & v336;
  v247 = v155 ^ v246;
  v156 = v59 ^ v155;
  v248 = v337 | v247;
  v60 = v248 ^ v425 & v59;
  v426 = v337 ^ v425;
  v249 = v156 ^ v426 & v248;
  v157 = v156 ^ (v426 | v60 ^ v337);
  v338 = __ROR4__(v60 ^ v426 ^ (v60 | v157), 19);
  v61 = __ROR4__(v60, 29);
  v158 = __ROR4__(v338 ^ v157 ^ v61, 31);
  v250 = __ROR4__((8 * v338) ^ v61 ^ v249, 25);
  v339 = __ROR4__(v158 ^ v338 ^ v250, 27);
  v62 = __ROR4__((v158 << 7) ^ v250 ^ v61, 10);
  a1[9] = v339;
  a1[8] = v158;
  a1[7] = v62;
  a1[6] = v250;
  v340 = a2[48] ^ v339;
  v251 = a2[51] ^ v250;
  v159 = v251 ^ a2[49] ^ v158;
  v252 = ~v251;
  v63 = v252 ^ a2[50] ^ v62;
  v253 = v340 ^ v252;
  v427 = v159;
  v160 = v63 ^ v253 & v159;
  v428 = v253 ^ v427;
  v341 = v428 ^ v340;
  v64 = v341 ^ v428 & v63;
  v342 = v160 & v341;
  v254 = v342 ^ v253;
  v429 = v342 ^ (v160 | v428);
  v161 = __ROR4__(v160, 19);
  v343 = __ROR4__(~(v64 ^ (v254 | v342)), 29);
  v430 = __ROR4__(v161 ^ v254 & v64 ^ v429 ^ v343, 31);
  v255 = __ROR4__((8 * v161) ^ v343 ^ v254, 25);
  v13 = __ROR4__((v430 << 7) ^ v255 ^ v343, 10);
  v162 = a2[52] ^ __ROR4__(v430 ^ v161 ^ v255, 27);
  v431 = a2[53] ^ v430;
  v256 = a2[55] ^ v255;
  v163 = v431 ^ v162;
  v432 = v256 ^ v431;
  v257 = ~v256;
  v65 = v432;
  v344 = v257 ^ a2[54] ^ v13;
  v433 = v344 ^ v163 & v432;
  v345 = v65 | v344;
  v66 = v257 ^ v65;
  v258 = v163 ^ v433 & v257;
  v67 = v345 ^ v433 ^ v66;
  v346 = (v258 | v67) ^ ~(v163 ^ v345);
  v434 = __ROR4__(v433, 19);
  v164 = __ROR4__(v67 ^ v258 & v163, 29);
  v259 = __ROR4__(v434 ^ v258 ^ v164, 31);
  v347 = __ROR4__((8 * v434) ^ v164 ^ v346, 25);
  v435 = a2[56] ^ __ROR4__(v259 ^ v434 ^ v347, 27);
  v165 = ~(a2[58] ^ __ROR4__((v259 << 7) ^ v347 ^ v164, 10));
  v68 = a2[59] ^ v347;
  v348 = v435 & v68;
  v436 = v68 ^ v435;
  v349 = v165 ^ v348;
  v260 = v349 ^ a2[57] ^ v259;
  v166 = v436 ^ (v68 | v165);
  v437 = v260 | v436;
  v167 = v260 ^ v166;
  v69 = v437 ^ v68;
  v438 = v167 ^ (v349 | v437);
  v70 = v438 ^ v349 ^ v69;
  v168 = ~v349 ^ v70 & v167;
  v439 = __ROR4__(v438, 19);
  v71 = __ROR4__(v70, 29);
  v261 = __ROR4__(v439 ^ v260 ^ v71, 31);
  v169 = __ROR4__((8 * v439) ^ v71 ^ v168, 25);
  v440 = a2[60] ^ __ROR4__(v261 ^ v439 ^ v169, 27);
  v72 = a2[62] ^ __ROR4__((v261 << 7) ^ v169 ^ v71, 10);
  v170 = a2[63] ^ v169;
  v350 = a2[61] ^ v261;
  v262 = v170 ^ (v72 | v350);
  v351 = v72 ^ v350;
  v73 = v262 ^ v72;
  v171 = v440 & (v351 | v170);
  v352 = v73 ^ v351;
  v172 = v262 ^ v171;
  v263 = v440 ^ (v352 | v262);
  v441 = v73 ^ (v352 | v440);
  v264 = v352 ^ v263;
  v74 = v264 ^ v73;
  v265 = v352 ^ v441 & v264;
  v353 = __ROR4__((v441 | ~v74) ^ v352, 19);
  v266 = __ROR4__(v265, 29);
  v173 = __ROR4__(v353 ^ v172 ^ v266, 31);
  v442 = __ROR4__((8 * v353) ^ v266 ^ v441, 25);
  v354 = a2[64] ^ __ROR4__(v173 ^ v353 ^ v442, 27);
  v267 = a2[66] ^ __ROR4__((v173 << 7) ^ v442 ^ v266, 10);
  v443 = v354 ^ a2[67] ^ v442;
  v75 = a2[65] ^ v173;
  v174 = v443 & v75;
  v76 = v267 ^ v75;
  v175 = v354 ^ v174;
  v355 = v76 ^ (v443 | v354);
  v77 = v443 ^ v76;
  v444 = v267 ^ v443;
  v268 = v77 ^ (v175 | v267);
  v78 = v175 | ~v77;
  v176 = v78 ^ v444 ^ v175;
  v445 = v355 | v444;
  v177 = __ROR4__(v445 ^ v176, 19);
  v269 = __ROR4__(v268, 29);
  v79 = __ROR4__(v177 ^ v445 ^ v78 ^ v269, 31);
  v356 = __ROR4__((8 * v177) ^ v269 ^ v355, 25);
  v14 = __ROR4__((v79 << 7) ^ v356 ^ v269, 10);
  v178 = a2[68] ^ __ROR4__(v79 ^ v177 ^ v356, 27);
  v80 = a2[69] ^ v79;
  v357 = a2[71] ^ v356;
  v446 = ~v178;
  v179 = v80 & ~v178;
  v270 = v179 ^ ~(a2[70] ^ v14);
  v180 = v357 | v179;
  v358 = v270 ^ v357;
  v81 = v180 ^ v80;
  v181 = v446 ^ v180;
  v447 = v81 | v446;
  v82 = v358 ^ v81;
  v271 = v447 & (v181 | v270);
  v182 = v82 ^ v181;
  v83 = v182 ^ v271 & v82;
  v183 = v447 ^ v271 & v182;
  v272 = __ROR4__(v271, 19);
  v359 = __ROR4__(v358, 29);
  v184 = __ROR4__(v272 ^ v183 ^ v359, 31);
  v84 = __ROR4__((8 * v272) ^ v359 ^ v83, 25);
  v273 = __ROR4__(v184 ^ v272 ^ v84, 27);
  v360 = __ROR4__((v184 << 7) ^ v84 ^ v359, 10);
  a1[10] = v273;
  a1[4] = v184;
  a1[11] = v360;
  a1[5] = v84;
  v185 = a2[73] ^ v184;
  v361 = a2[74] ^ v360;
  v85 = a2[75] ^ v84;
  v448 = a2[72] ^ v273;
  v274 = v85 ^ v361 & v448;
  v362 = v274 ^ v185 ^ v361;
  v86 = v185 ^ (v448 | v85);
  v449 = v362 ^ v448;
  v186 = v86;
  v87 = v274 ^ (v449 | v86);
  v450 = v186 & v274 ^ v449;
  v363 = __ROR4__(v362, 19);
  v187 = __ROR4__(v450 ^ v87 ^ v186, 29);
  v88 = __ROR4__(v363 ^ v87 ^ v187, 31);
  v451 = __ROR4__((8 * v363) ^ v187 ^ ~v450, 25);
  v15 = __ROR4__((v88 << 7) ^ v451 ^ v187, 10);
  v364 = a2[76] ^ __ROR4__(v88 ^ v363 ^ v451, 27);
  v89 = a2[77] ^ v88;
  v188 = a2[78] ^ v15;
  v452 = a2[79] ^ v451;
  v275 = v364;
  v365 = v452 | v364;
  v453 = v89 ^ v452;
  v90 = v275 & v89;
  v276 = v188 ^ v275;
  v189 = v453 ^ v188;
  v277 = v90 | v276;
  v454 = v277 ^ v365 & v453;
  v366 = v90 ^ v365;
  v278 = v189 ^ v366 & v277;
  v190 = v189 ^ (v366 | v454 ^ v90);
  v91 = __ROR4__(v454 ^ v366 ^ (v454 | v190), 19);
  v455 = __ROR4__(v454, 29);
  v191 = __ROR4__(v91 ^ v190 ^ v455, 31);
  v279 = __ROR4__((8 * v91) ^ v455 ^ v278, 25);
  v16 = __ROR4__((v191 << 7) ^ v279 ^ v455, 10);
  v92 = a2[80] ^ __ROR4__(v191 ^ v91 ^ v279, 27);
  v280 = a2[83] ^ v279;
  v192 = v280 ^ a2[81] ^ v191;
  v281 = ~v280;
  v456 = v281 ^ a2[82] ^ v16;
  v282 = v92 ^ v281;
  v367 = v192;
  v193 = v456 ^ v282 & v192;
  v368 = v282 ^ v367;
  v93 = v368 ^ v92;
  v457 = v93 ^ v368 & v456;
  v94 = v193 & v93;
  v283 = v94 ^ v282;
  v369 = v94 ^ (v193 | v368);
  v194 = __ROR4__(v193, 19);
  v95 = __ROR4__(~(v457 ^ (v283 | v94)), 29);
  v370 = __ROR4__(v194 ^ v283 & v457 ^ v369 ^ v95, 31);
  v284 = __ROR4__((8 * v194) ^ v95 ^ v283, 25);
  v17 = __ROR4__((v370 << 7) ^ v284 ^ v95, 10);
  v195 = a2[84] ^ __ROR4__(v370 ^ v194 ^ v284, 27);
  v371 = a2[85] ^ v370;
  v285 = a2[87] ^ v284;
  v196 = v371 ^ v195;
  v372 = v285 ^ v371;
  v286 = ~v285;
  v458 = v372;
  v96 = v286 ^ a2[86] ^ v17;
  v373 = v96 ^ v196 & v372;
  v97 = v458 | v96;
  v459 = v286 ^ v458;
  v287 = v196 ^ v373 & v286;
  v460 = v97 ^ v373 ^ v459;
  v98 = (v287 | v460) ^ ~(v196 ^ v97);
  v374 = __ROR4__(v373, 19);
  v197 = __ROR4__(v460 ^ v287 & v196, 29);
  v288 = __ROR4__(v374 ^ v287 ^ v197, 31);
  v99 = __ROR4__((8 * v374) ^ v197 ^ v98, 25);
  v375 = a2[88] ^ __ROR4__(v288 ^ v374 ^ v99, 27);
  v198 = ~(a2[90] ^ __ROR4__((v288 << 7) ^ v99 ^ v197, 10));
  v461 = a2[91] ^ v99;
  v100 = v375 & v461;
  v376 = v461 ^ v375;
  v101 = v198 ^ v100;
  v289 = v101 ^ a2[89] ^ v288;
  v199 = v376 ^ (v461 | v198);
  v377 = v289 | v376;
  v200 = v289 ^ v199;
  v462 = v377 ^ v461;
  v378 = v200 ^ (v101 | v377);
  v463 = v378 ^ v101 ^ v462;
  v201 = ~v101 ^ v463 & v200;
  v379 = __ROR4__(v378, 19);
  v464 = __ROR4__(v463, 29);
  v290 = __ROR4__(v379 ^ v289 ^ v464, 31);
  v202 = __ROR4__((8 * v379) ^ v464 ^ v201, 25);
  v380 = a2[92] ^ __ROR4__(v290 ^ v379 ^ v202, 27);
  v465 = a2[94] ^ __ROR4__((v290 << 7) ^ v202 ^ v464, 10);
  v203 = a2[95] ^ v202;
  v102 = a2[93] ^ v290;
  v291 = v203 ^ (v465 | v102);
  v103 = v465 ^ v102;
  v466 = v291 ^ v465;
  v204 = v380 & (v103 | v203);
  v104 = v466 ^ v103;
  v205 = v291 ^ v204;
  v292 = v380 ^ (v104 | v291);
  v381 = v466 ^ (v104 | v380);
  v293 = v104 ^ v292;
  v467 = v293 ^ v466;
  v294 = v104 ^ v381 & v293;
  v105 = __ROR4__((v381 | ~v467) ^ v104, 19);
  v295 = __ROR4__(v294, 29);
  v206 = __ROR4__(v105 ^ v205 ^ v295, 31);
  v382 = __ROR4__((8 * v105) ^ v295 ^ v381, 25);
  v18 = __ROR4__((v206 << 7) ^ v382 ^ v295, 10);
  v106 = a2[96] ^ __ROR4__(v206 ^ v105 ^ v382, 27);
  v207 = a2[97] ^ v206;
  v296 = a2[98] ^ v18;
  v383 = a2[99] ^ v382;
  a1[3] = v106;
  a1[2] = v207;
  a1[1] = v296;
  *a1 = v383;
  a1[32] = 80;
  return __readfsqword(0x28u) ^ v473;
}
// 4056DA: using guessed type unsigned __int16 dest[2];
// 4056DA: using guessed type unsigned __int16 anonymous_1[2];
// 4056DA: using guessed type unsigned __int16 anonymous_2[6];

//----- (0000000000406F54) ----------------------------------------------------
__int64 __fastcall sosemanuk_internal(unsigned int *a1)
{
  __int64 result; // rax
  int v2; // [rsp+8h] [rbp-158h]
  int v3; // [rsp+Ch] [rbp-154h]
  int v4; // [rsp+10h] [rbp-150h]
  int v5; // [rsp+14h] [rbp-14Ch]
  int v6; // [rsp+18h] [rbp-148h]
  int v7; // [rsp+1Ch] [rbp-144h]
  int v8; // [rsp+20h] [rbp-140h]
  int v9; // [rsp+24h] [rbp-13Ch]
  int v10; // [rsp+28h] [rbp-138h]
  int v11; // [rsp+2Ch] [rbp-134h]
  int v12; // [rsp+30h] [rbp-130h]
  int v13; // [rsp+34h] [rbp-12Ch]
  int v14; // [rsp+38h] [rbp-128h]
  int v15; // [rsp+3Ch] [rbp-124h]
  int v16; // [rsp+40h] [rbp-120h]
  int v17; // [rsp+44h] [rbp-11Ch]
  int v18; // [rsp+48h] [rbp-118h]
  int v19; // [rsp+4Ch] [rbp-114h]
  int v20; // [rsp+50h] [rbp-110h]
  int v21; // [rsp+54h] [rbp-10Ch]
  int v22; // [rsp+6Ch] [rbp-F4h]
  int v23; // [rsp+74h] [rbp-ECh]
  int v24; // [rsp+7Ch] [rbp-E4h]
  int v25; // [rsp+84h] [rbp-DCh]
  int v26; // [rsp+8Ch] [rbp-D4h]
  int v27; // [rsp+94h] [rbp-CCh]
  int v28; // [rsp+9Ch] [rbp-C4h]
  int v29; // [rsp+A4h] [rbp-BCh]
  int v30; // [rsp+ACh] [rbp-B4h]
  int v31; // [rsp+B4h] [rbp-ACh]
  int v32; // [rsp+BCh] [rbp-A4h]
  int v33; // [rsp+C4h] [rbp-9Ch]
  int v34; // [rsp+CCh] [rbp-94h]
  int v35; // [rsp+D4h] [rbp-8Ch]
  int v36; // [rsp+DCh] [rbp-84h]
  int v37; // [rsp+E4h] [rbp-7Ch]
  int v38; // [rsp+ECh] [rbp-74h]
  int v39; // [rsp+F4h] [rbp-6Ch]
  unsigned int v40; // [rsp+10Ch] [rbp-54h]
  unsigned int v41; // [rsp+10Ch] [rbp-54h]
  unsigned int v42; // [rsp+10Ch] [rbp-54h]
  unsigned int v43; // [rsp+10Ch] [rbp-54h]
  unsigned int v44; // [rsp+10Ch] [rbp-54h]
  unsigned int v45; // [rsp+110h] [rbp-50h]
  unsigned int v46; // [rsp+110h] [rbp-50h]
  unsigned int v47; // [rsp+110h] [rbp-50h]
  unsigned int v48; // [rsp+110h] [rbp-50h]
  unsigned int v49; // [rsp+110h] [rbp-50h]
  unsigned int v50; // [rsp+114h] [rbp-4Ch]
  unsigned int v51; // [rsp+114h] [rbp-4Ch]
  unsigned int v52; // [rsp+114h] [rbp-4Ch]
  unsigned int v53; // [rsp+114h] [rbp-4Ch]
  unsigned int v54; // [rsp+114h] [rbp-4Ch]
  unsigned int v55; // [rsp+118h] [rbp-48h]
  unsigned int v56; // [rsp+118h] [rbp-48h]
  unsigned int v57; // [rsp+118h] [rbp-48h]
  unsigned int v58; // [rsp+118h] [rbp-48h]
  int v59; // [rsp+11Ch] [rbp-44h]
  int v60; // [rsp+11Ch] [rbp-44h]
  int v61; // [rsp+11Ch] [rbp-44h]
  int v62; // [rsp+11Ch] [rbp-44h]
  int v63; // [rsp+11Ch] [rbp-44h]
  int v64; // [rsp+11Ch] [rbp-44h]
  int v65; // [rsp+11Ch] [rbp-44h]
  int v66; // [rsp+11Ch] [rbp-44h]
  int v67; // [rsp+11Ch] [rbp-44h]
  int v68; // [rsp+11Ch] [rbp-44h]
  int v69; // [rsp+11Ch] [rbp-44h]
  int v70; // [rsp+11Ch] [rbp-44h]
  int v71; // [rsp+11Ch] [rbp-44h]
  int v72; // [rsp+11Ch] [rbp-44h]
  int v73; // [rsp+11Ch] [rbp-44h]
  int v74; // [rsp+120h] [rbp-40h]
  int v75; // [rsp+120h] [rbp-40h]
  int v76; // [rsp+120h] [rbp-40h]
  int v77; // [rsp+120h] [rbp-40h]
  int v78; // [rsp+120h] [rbp-40h]
  int v79; // [rsp+120h] [rbp-40h]
  int v80; // [rsp+120h] [rbp-40h]
  int v81; // [rsp+120h] [rbp-40h]
  int v82; // [rsp+120h] [rbp-40h]
  int v83; // [rsp+120h] [rbp-40h]
  int v84; // [rsp+124h] [rbp-3Ch]
  int v85; // [rsp+124h] [rbp-3Ch]
  int v86; // [rsp+124h] [rbp-3Ch]
  int v87; // [rsp+124h] [rbp-3Ch]
  int v88; // [rsp+124h] [rbp-3Ch]
  int v89; // [rsp+124h] [rbp-3Ch]
  int v90; // [rsp+124h] [rbp-3Ch]
  int v91; // [rsp+124h] [rbp-3Ch]
  int v92; // [rsp+124h] [rbp-3Ch]
  int v93; // [rsp+124h] [rbp-3Ch]
  int v94; // [rsp+128h] [rbp-38h]
  int v95; // [rsp+128h] [rbp-38h]
  int v96; // [rsp+128h] [rbp-38h]
  int v97; // [rsp+128h] [rbp-38h]
  int v98; // [rsp+128h] [rbp-38h]
  int v99; // [rsp+128h] [rbp-38h]
  int v100; // [rsp+128h] [rbp-38h]
  int v101; // [rsp+128h] [rbp-38h]
  int v102; // [rsp+128h] [rbp-38h]
  int v103; // [rsp+128h] [rbp-38h]
  int v104; // [rsp+12Ch] [rbp-34h]
  int v105; // [rsp+12Ch] [rbp-34h]
  int v106; // [rsp+12Ch] [rbp-34h]
  int v107; // [rsp+12Ch] [rbp-34h]
  int v108; // [rsp+12Ch] [rbp-34h]
  int v109; // [rsp+12Ch] [rbp-34h]
  int v110; // [rsp+12Ch] [rbp-34h]
  int v111; // [rsp+12Ch] [rbp-34h]
  int v112; // [rsp+12Ch] [rbp-34h]
  int v113; // [rsp+12Ch] [rbp-34h]
  int v114; // [rsp+130h] [rbp-30h]
  int v115; // [rsp+130h] [rbp-30h]
  int v116; // [rsp+130h] [rbp-30h]
  int v117; // [rsp+130h] [rbp-30h]
  int v118; // [rsp+130h] [rbp-30h]
  int v119; // [rsp+130h] [rbp-30h]
  int v120; // [rsp+130h] [rbp-30h]
  int v121; // [rsp+130h] [rbp-30h]
  int v122; // [rsp+130h] [rbp-30h]
  int v123; // [rsp+130h] [rbp-30h]
  int v124; // [rsp+130h] [rbp-30h]
  int v125; // [rsp+130h] [rbp-30h]
  int v126; // [rsp+130h] [rbp-30h]
  int v127; // [rsp+130h] [rbp-30h]
  int v128; // [rsp+130h] [rbp-30h]
  int v129; // [rsp+130h] [rbp-30h]
  int v130; // [rsp+130h] [rbp-30h]
  int v131; // [rsp+130h] [rbp-30h]
  int v132; // [rsp+130h] [rbp-30h]
  unsigned int v133; // [rsp+130h] [rbp-30h]
  int v134; // [rsp+134h] [rbp-2Ch]
  int v135; // [rsp+134h] [rbp-2Ch]
  int v136; // [rsp+134h] [rbp-2Ch]
  int v137; // [rsp+134h] [rbp-2Ch]
  int v138; // [rsp+134h] [rbp-2Ch]
  int v139; // [rsp+134h] [rbp-2Ch]
  int v140; // [rsp+134h] [rbp-2Ch]
  int v141; // [rsp+134h] [rbp-2Ch]
  int v142; // [rsp+134h] [rbp-2Ch]
  int v143; // [rsp+134h] [rbp-2Ch]
  int v144; // [rsp+134h] [rbp-2Ch]
  int v145; // [rsp+134h] [rbp-2Ch]
  int v146; // [rsp+134h] [rbp-2Ch]
  int v147; // [rsp+134h] [rbp-2Ch]
  int v148; // [rsp+134h] [rbp-2Ch]
  int v149; // [rsp+134h] [rbp-2Ch]
  int v150; // [rsp+134h] [rbp-2Ch]
  int v151; // [rsp+134h] [rbp-2Ch]
  int v152; // [rsp+134h] [rbp-2Ch]
  unsigned int v153; // [rsp+134h] [rbp-2Ch]
  unsigned int v154; // [rsp+138h] [rbp-28h]
  unsigned int v155; // [rsp+138h] [rbp-28h]
  int v156; // [rsp+138h] [rbp-28h]
  unsigned int v157; // [rsp+13Ch] [rbp-24h]
  unsigned int v158; // [rsp+13Ch] [rbp-24h]
  int v159; // [rsp+13Ch] [rbp-24h]
  unsigned int v160; // [rsp+140h] [rbp-20h]
  unsigned int v161; // [rsp+140h] [rbp-20h]
  int v162; // [rsp+140h] [rbp-20h]
  unsigned int v163; // [rsp+144h] [rbp-1Ch]
  unsigned int v164; // [rsp+144h] [rbp-1Ch]
  int v165; // [rsp+144h] [rbp-1Ch]
  unsigned int v166; // [rsp+148h] [rbp-18h]
  unsigned int v167; // [rsp+148h] [rbp-18h]
  int v168; // [rsp+148h] [rbp-18h]
  unsigned int v169; // [rsp+14Ch] [rbp-14h]
  unsigned int v170; // [rsp+14Ch] [rbp-14h]
  int v171; // [rsp+14Ch] [rbp-14h]
  unsigned int v172; // [rsp+150h] [rbp-10h]
  unsigned int v173; // [rsp+150h] [rbp-10h]
  int v174; // [rsp+150h] [rbp-10h]
  unsigned int v175; // [rsp+154h] [rbp-Ch]
  unsigned int v176; // [rsp+154h] [rbp-Ch]
  unsigned int v177; // [rsp+154h] [rbp-Ch]
  unsigned int v178; // [rsp+158h] [rbp-8h]
  unsigned int v179; // [rsp+158h] [rbp-8h]
  unsigned int v180; // [rsp+158h] [rbp-8h]
  unsigned int v181; // [rsp+15Ch] [rbp-4h]
  unsigned int v182; // [rsp+15Ch] [rbp-4h]

  v178 = a1[1];
  v175 = a1[2];
  v172 = a1[3];
  v169 = a1[4];
  v166 = a1[5];
  v163 = a1[6];
  v160 = a1[7];
  v157 = a1[8];
  v154 = a1[9];
  if ( (a1[10] & 1) != 0 )
    v2 = v157 ^ v178;
  else
    v2 = a1[1];
  v134 = a1[11] + v2;
  v114 = __ROR4__(1415926535 * a1[10], 25);
  v181 = v154 ^ mul_a[HIBYTE(*a1)] ^ (*a1 << 8) ^ (v172 >> 8) ^ mul_ia[(unsigned __int8)v172];
  v104 = v114 ^ (v154 + v134);
  if ( (v134 & 1) != 0 )
    v3 = v154 ^ v175;
  else
    v3 = a1[2];
  v135 = v114 + v3;
  v115 = __ROR4__(1415926535 * (a1[11] + v2), 25);
  v50 = a1[1];
  v179 = v181 ^ mul_a[HIBYTE(v178)] ^ (v178 << 8) ^ (v169 >> 8) ^ mul_ia[(unsigned __int8)v169];
  v94 = v115 ^ (v181 + v135);
  if ( (v135 & 1) != 0 )
    v4 = v181 ^ v172;
  else
    v4 = a1[3];
  v39 = v135;
  v136 = v115 + v4;
  v116 = __ROR4__(1415926535 * v39, 25);
  v45 = a1[2];
  v176 = v179 ^ mul_a[HIBYTE(v175)] ^ (v175 << 8) ^ (v166 >> 8) ^ mul_ia[(unsigned __int8)v166];
  v84 = v116 ^ (v179 + v136);
  if ( (v136 & 1) != 0 )
    v5 = v179 ^ v169;
  else
    v5 = a1[4];
  v38 = v136;
  v137 = v116 + v5;
  v117 = __ROR4__(1415926535 * v38, 25);
  v40 = a1[3];
  v173 = v176 ^ mul_a[HIBYTE(v172)] ^ (v172 << 8) ^ (v163 >> 8) ^ mul_ia[(unsigned __int8)v163];
  v59 = v104;
  v105 = v117 ^ (v176 + v137) ^ v84 & v104;
  v85 = v105 ^ v94 ^ v84;
  v74 = v94 ^ (v59 | v117 ^ (v176 + v137));
  v60 = v85 ^ v59;
  v95 = v74;
  v75 = v105 ^ (v60 | v74);
  v61 = v95 & v105 ^ v60;
  encode32le((__int64)(a1 + 12), *a1 ^ v85);
  encode32le((__int64)(a1 + 13), v50 ^ v75);
  encode32le((__int64)(a1 + 14), v45 ^ v61 ^ v75 ^ v95);
  encode32le((__int64)(a1 + 15), v40 ^ ~v61);
  if ( (v137 & 1) != 0 )
    v6 = v176 ^ v166;
  else
    v6 = v166;
  v37 = v137;
  v138 = v117 + v6;
  v118 = __ROR4__(1415926535 * v37, 25);
  v55 = v169;
  v170 = v173 ^ mul_a[HIBYTE(v169)] ^ (v169 << 8) ^ (v160 >> 8) ^ mul_ia[(unsigned __int8)v160];
  v106 = v118 ^ (v173 + v138);
  if ( (v138 & 1) != 0 )
    v7 = v173 ^ v163;
  else
    v7 = v163;
  v36 = v138;
  v139 = v118 + v7;
  v119 = __ROR4__(1415926535 * v36, 25);
  v51 = v166;
  v167 = v170 ^ mul_a[HIBYTE(v166)] ^ (v166 << 8) ^ (v157 >> 8) ^ mul_ia[(unsigned __int8)v157];
  v96 = v119 ^ (v170 + v139);
  if ( (v139 & 1) != 0 )
    v8 = v170 ^ v160;
  else
    v8 = v160;
  v35 = v139;
  v140 = v119 + v8;
  v120 = __ROR4__(1415926535 * v35, 25);
  v46 = v163;
  v164 = v167 ^ mul_a[HIBYTE(v163)] ^ (v163 << 8) ^ (v154 >> 8) ^ mul_ia[(unsigned __int8)v154];
  v86 = v120 ^ (v167 + v140);
  if ( (v140 & 1) != 0 )
    v9 = v167 ^ v157;
  else
    v9 = v157;
  v34 = v140;
  v141 = v120 + v9;
  v121 = __ROR4__(1415926535 * v34, 25);
  v41 = v160;
  v161 = v164 ^ mul_a[HIBYTE(v160)] ^ (v160 << 8) ^ (v181 >> 8) ^ mul_ia[(unsigned __int8)v181];
  v62 = v106;
  v107 = v121 ^ (v164 + v141) ^ v86 & v106;
  v87 = v107 ^ v96 ^ v86;
  v76 = v96 ^ (v62 | v121 ^ (v164 + v141));
  v63 = v87 ^ v62;
  v97 = v76;
  v77 = v107 ^ (v63 | v76);
  v64 = v97 & v107 ^ v63;
  encode32le((__int64)(a1 + 16), v55 ^ v87);
  encode32le((__int64)(a1 + 17), v51 ^ v77);
  encode32le((__int64)(a1 + 18), v46 ^ v64 ^ v77 ^ v97);
  encode32le((__int64)(a1 + 19), v41 ^ ~v64);
  if ( (v141 & 1) != 0 )
    v10 = v164 ^ v154;
  else
    v10 = v154;
  v33 = v141;
  v142 = v121 + v10;
  v122 = __ROR4__(1415926535 * v33, 25);
  v56 = v157;
  v158 = v161 ^ mul_a[HIBYTE(v157)] ^ (v157 << 8) ^ (v179 >> 8) ^ mul_ia[(unsigned __int8)v179];
  v108 = v122 ^ (v161 + v142);
  if ( (v142 & 1) != 0 )
    v11 = v161 ^ v181;
  else
    v11 = v181;
  v32 = v142;
  v143 = v122 + v11;
  v123 = __ROR4__(1415926535 * v32, 25);
  v52 = v154;
  v155 = v158 ^ mul_a[HIBYTE(v154)] ^ (v154 << 8) ^ (v176 >> 8) ^ mul_ia[(unsigned __int8)v176];
  v98 = v123 ^ (v158 + v143);
  if ( (v143 & 1) != 0 )
    v12 = v158 ^ v179;
  else
    v12 = v179;
  v31 = v143;
  v144 = v123 + v12;
  v124 = __ROR4__(1415926535 * v31, 25);
  v47 = v181;
  v182 = v155 ^ mul_a[HIBYTE(v181)] ^ (v181 << 8) ^ (v173 >> 8) ^ mul_ia[(unsigned __int8)v173];
  v88 = v124 ^ (v155 + v144);
  if ( (v144 & 1) != 0 )
    v13 = v155 ^ v176;
  else
    v13 = v176;
  v30 = v144;
  v145 = v124 + v13;
  v125 = __ROR4__(1415926535 * v30, 25);
  v42 = v179;
  v180 = v182 ^ mul_a[HIBYTE(v179)] ^ (v179 << 8) ^ (v170 >> 8) ^ mul_ia[(unsigned __int8)v170];
  v65 = v108;
  v109 = v125 ^ (v182 + v145) ^ v88 & v108;
  v89 = v109 ^ v98 ^ v88;
  v78 = v98 ^ (v65 | v125 ^ (v182 + v145));
  v66 = v89 ^ v65;
  v99 = v78;
  v79 = v109 ^ (v66 | v78);
  v67 = v99 & v109 ^ v66;
  encode32le((__int64)(a1 + 20), v56 ^ v89);
  encode32le((__int64)(a1 + 21), v52 ^ v79);
  encode32le((__int64)(a1 + 22), v47 ^ v67 ^ v79 ^ v99);
  encode32le((__int64)(a1 + 23), v42 ^ ~v67);
  if ( (v145 & 1) != 0 )
    v14 = v182 ^ v173;
  else
    v14 = v173;
  v29 = v145;
  v146 = v125 + v14;
  v126 = __ROR4__(1415926535 * v29, 25);
  v57 = v176;
  v177 = v180 ^ mul_a[HIBYTE(v176)] ^ (v176 << 8) ^ (v167 >> 8) ^ mul_ia[(unsigned __int8)v167];
  v110 = v126 ^ (v180 + v146);
  if ( (v146 & 1) != 0 )
    v15 = v180 ^ v170;
  else
    v15 = v170;
  v28 = v146;
  v147 = v126 + v15;
  v127 = __ROR4__(1415926535 * v28, 25);
  v53 = v173;
  v174 = v177 ^ mul_a[HIBYTE(v173)] ^ (v173 << 8) ^ (v164 >> 8) ^ mul_ia[(unsigned __int8)v164];
  v100 = v127 ^ (v177 + v147);
  if ( (v147 & 1) != 0 )
    v16 = v177 ^ v167;
  else
    v16 = v167;
  v27 = v147;
  v148 = v127 + v16;
  v128 = __ROR4__(1415926535 * v27, 25);
  v48 = v170;
  v171 = v174 ^ mul_a[HIBYTE(v170)] ^ (v170 << 8) ^ (v161 >> 8) ^ mul_ia[(unsigned __int8)v161];
  v90 = v128 ^ (v174 + v148);
  if ( (v148 & 1) != 0 )
    v17 = v174 ^ v164;
  else
    v17 = v164;
  v26 = v148;
  v149 = v128 + v17;
  v129 = __ROR4__(1415926535 * v26, 25);
  v43 = v167;
  v168 = v171 ^ mul_a[HIBYTE(v167)] ^ (v167 << 8) ^ (v158 >> 8) ^ mul_ia[(unsigned __int8)v158];
  v68 = v110;
  v111 = v129 ^ (v171 + v149) ^ v90 & v110;
  v91 = v111 ^ v100 ^ v90;
  v80 = v100 ^ (v68 | v129 ^ (v171 + v149));
  v69 = v91 ^ v68;
  v101 = v80;
  v81 = v111 ^ (v69 | v80);
  v70 = v101 & v111 ^ v69;
  encode32le((__int64)(a1 + 24), v57 ^ v91);
  encode32le((__int64)(a1 + 25), v53 ^ v81);
  encode32le((__int64)(a1 + 26), v48 ^ v70 ^ v81 ^ v101);
  encode32le((__int64)(a1 + 27), v43 ^ ~v70);
  if ( (v149 & 1) != 0 )
    v18 = v171 ^ v161;
  else
    v18 = v161;
  v25 = v149;
  v150 = v129 + v18;
  v130 = __ROR4__(1415926535 * v25, 25);
  v58 = v164;
  v165 = v168 ^ mul_a[HIBYTE(v164)] ^ (v164 << 8) ^ (v155 >> 8) ^ mul_ia[(unsigned __int8)v155];
  v112 = v130 ^ (v168 + v150);
  if ( (v150 & 1) != 0 )
    v19 = v168 ^ v158;
  else
    v19 = v158;
  v24 = v150;
  v151 = v130 + v19;
  v131 = __ROR4__(1415926535 * v24, 25);
  v54 = v161;
  v162 = v165 ^ mul_a[HIBYTE(v161)] ^ (v161 << 8) ^ (v182 >> 8) ^ mul_ia[(unsigned __int8)v182];
  v102 = v131 ^ (v165 + v151);
  if ( (v151 & 1) != 0 )
    v20 = v165 ^ v155;
  else
    v20 = v155;
  v23 = v151;
  v152 = v131 + v20;
  v132 = __ROR4__(1415926535 * v23, 25);
  v49 = v158;
  v159 = v162 ^ mul_a[HIBYTE(v158)] ^ (v158 << 8) ^ (v180 >> 8) ^ mul_ia[(unsigned __int8)v180];
  v92 = v132 ^ (v162 + v152);
  if ( (v152 & 1) != 0 )
    v21 = v162 ^ v182;
  else
    v21 = v182;
  v22 = v152;
  v153 = v132 + v21;
  v133 = __ROR4__(1415926535 * v22, 25);
  v44 = v155;
  v156 = v159 ^ mul_a[HIBYTE(v155)] ^ (v155 << 8) ^ (v177 >> 8) ^ mul_ia[(unsigned __int8)v177];
  v71 = v112;
  v113 = v133 ^ (v159 + v153) ^ v92 & v112;
  v93 = v113 ^ v102 ^ v92;
  v82 = v102 ^ (v71 | v133 ^ (v159 + v153));
  v72 = v93 ^ v71;
  v103 = v82;
  v83 = v113 ^ (v72 | v82);
  v73 = v103 & v113 ^ v72;
  encode32le((__int64)(a1 + 28), v58 ^ v93);
  encode32le((__int64)(a1 + 29), v54 ^ v83);
  encode32le((__int64)(a1 + 30), v49 ^ v73 ^ v83 ^ v103);
  encode32le((__int64)(a1 + 31), v44 ^ ~v73);
  *a1 = v182;
  a1[1] = v180;
  a1[2] = v177;
  a1[3] = v174;
  a1[4] = v171;
  a1[5] = v168;
  a1[6] = v165;
  a1[7] = v162;
  a1[8] = v159;
  a1[9] = v156;
  a1[10] = v153;
  result = v133;
  a1[11] = v133;
  return result;
}
// 6092E0: using guessed type int mul_a[256];
// 6096E0: using guessed type int mul_ia[256];

//----- (00000000004081CD) ----------------------------------------------------
__int64 __fastcall encode32le(__int64 a1, unsigned int a2)
{
  __int64 result; // rax

  *(_BYTE *)a1 = a2;
  *(_WORD *)(a1 + 1) = a2 >> 8;
  result = HIBYTE(a2);
  *(_BYTE *)(a1 + 3) = HIBYTE(a2);
  return result;
}

//----- (0000000000408215) ----------------------------------------------------
void *__fastcall sosemanuk_prng(unsigned int *a1, char *a2, unsigned __int64 a3)
{
  void *result; // rax
  size_t v4; // [rsp+8h] [rbp-28h]
  char *dest; // [rsp+10h] [rbp-20h]
  unsigned __int64 n; // [rsp+28h] [rbp-8h]

  dest = a2;
  v4 = a3;
  result = (void *)a1[32];
  if ( (unsigned int)result <= 0x4F )
  {
    n = 80LL - a1[32];
    if ( n > a3 )
      n = a3;
    memcpy(a2, (char *)a1 + a1[32] + 48, n);
    dest = &a2[n];
    v4 -= n;
    result = a1;
    a1[32] += n;
  }
  while ( v4 )
  {
    sosemanuk_internal(a1);
    if ( v4 <= 0x4F )
    {
      memcpy(dest, a1 + 12, v4);
      result = a1;
      a1[32] = v4;
      v4 = 0LL;
    }
    else
    {
      result = memcpy(dest, a1 + 12, 0x50uLL);
      dest += 80;
      v4 -= 80LL;
    }
  }
  return result;
}

//----- (000000000040831F) ----------------------------------------------------
_BYTE *__fastcall sosemanuk_encrypt(__int64 a1, _BYTE *a2, _BYTE *a3, unsigned __int64 a4)
{
  _BYTE *result; // rax
  unsigned __int64 v5; // [rsp+0h] [rbp-30h]
  _BYTE *v6; // [rsp+8h] [rbp-28h]
  _BYTE *v7; // [rsp+10h] [rbp-20h]
  unsigned __int64 v8; // [rsp+28h] [rbp-8h]

  v7 = a2;
  v6 = a3;
  v5 = a4;
  result = (_BYTE *)*(unsigned int *)(a1 + 128);
  if ( (unsigned int)result <= 0x4F )
  {
    v8 = 80LL - *(unsigned int *)(a1 + 128);
    if ( v8 > a4 )
      v8 = a4;
    xorbuf((_BYTE *)(a1 + 48 + *(unsigned int *)(a1 + 128)), a2, a3, v8);
    v7 = &a2[v8];
    v6 += v8;
    v5 -= v8;
    result = (_BYTE *)a1;
    *(_DWORD *)(a1 + 128) += v8;
  }
  while ( v5 )
  {
    sosemanuk_internal((unsigned int *)a1);
    if ( v5 <= 0x4F )
    {
      xorbuf((_BYTE *)(a1 + 48), v7, v6, v5);
      result = (_BYTE *)a1;
      *(_DWORD *)(a1 + 128) = v5;
      v5 = 0LL;
    }
    else
    {
      result = xorbuf((_BYTE *)(a1 + 48), v7, v6, 80LL);
      v7 += 80;
      v6 += 80;
      v5 -= 80LL;
    }
  }
  return result;
}

//----- (0000000000408446) ----------------------------------------------------
_BYTE *__fastcall xorbuf(_BYTE *a1, _BYTE *a2, _BYTE *a3, __int64 a4)
{
  _BYTE *result; // rax

  while ( --a4 != -1 )
  {
    result = a3;
    *a3++ = *a2++ ^ *a1++;
  }
  return result;
}

//----- (00000000004084A0) ----------------------------------------------------
void _libc_csu_init(void)
{
  init_proc();
}

//----- (0000000000408530) ----------------------------------------------------
int __fastcall fstat(int fildes, struct stat *stat_buf)
{
  return __fxstat(1, fildes, stat_buf);
}

//----- (0000000000408540) ----------------------------------------------------
void (*_do_global_ctors_aux())(void)
{
  void (*result)(void); // rax
  __int64 v1; // rbx

  result = (void (*)(void))_CTOR_LIST__;
  if ( _CTOR_LIST__ != -1 )
  {
    v1 = 0LL;
    do
    {
      result();
      result = *(void (**)(void))(v1 + 6328312);
      v1 -= 8LL;
    }
    while ( result != (void (*)(void))-1LL );
  }
  return result;
}
// 609000: using guessed type __int64 _CTOR_LIST__;

//----- (0000000000408574) ----------------------------------------------------
__int64 *term_proc()
{
  return _do_global_dtors_aux();
}

// nfuncs=85 queued=35 decompiled=35 lumina nreq=0 worse=0 better=0
// ALL OK, 35 function(s) have been successfully decompiled