API tools faq
paste
Guest User

Untitled

a guest
Dec 16th, 2011
277
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.70 KB | None | 0 0
raw download clone embed print report
  1. signed int __cdecl decompress_segment(unsigned char *output, unsigned int output_size, unsigned char *input, unsigned char **input_end)
  2. {
  3.     signed int v4; // esi@1
  4.     int v5; // edi@1
  5.     signed int result; // eax@2
  6.     unsigned int v7; // ecx@8
  7.     int v8; // edx@9
  8.     unsigned int v9; // ebx@9
  9.     int v10; // ebx@12
  10.     unsigned int v11; // ecx@12
  11.     int v12; // edx@13
  12.     int v13; // ecx@13
  13.     char v14; // al@13
  14.     int v15; // eax@18
  15.     unsigned int v16; // ecx@21
  16.     int v17; // ecx@22
  17.     int v18; // esi@25
  18.     unsigned int v19; // ecx@25
  19.     int v20; // edx@26
  20.     int v21; // ecx@26
  21.     char v22; // al@26
  22.     int v23; // ebx@26
  23.     unsigned int v24; // ecx@30
  24.     int v25; // edx@31
  25.     int v26; // ecx@31
  26.     char v27; // al@31
  27.     unsigned int v28; // ecx@38
  28.     int v29; // edx@39
  29.     int v30; // ecx@39
  30.     char v31; // al@39
  31.     unsigned int v32; // ecx@43
  32.     int v33; // edx@44
  33.     int v34; // ecx@44
  34.     char v35; // al@44
  35.     unsigned int v36; // ecx@47
  36.     int v37; // edx@48
  37.     int v38; // ecx@48
  38.     char v39; // al@48
  39.     signed int v40; // ebx@52
  40.     int v41; // esi@54
  41.     unsigned int v42; // edx@55
  42.     int v43; // ecx@55
  43.     int v44; // edx@55
  44.     char v45; // al@55
  45.     signed int v46; // eax@57
  46.     signed int v47; // eax@59
  47.     int v48; // ebx@59
  48.     unsigned int v49; // ecx@59
  49.     int v50; // edx@60
  50.     int v51; // ecx@60
  51.     char v52; // al@60
  52.     int v53; // esi@60
  53.     unsigned int v54; // ecx@64
  54.     int v55; // edx@65
  55.     int v56; // ecx@65
  56.     char v57; // al@65
  57.     unsigned int v58; // ecx@72
  58.     int v59; // edx@73
  59.     int v60; // ecx@73
  60.     char v61; // al@73
  61.     unsigned int v62; // ecx@77
  62.     int v63; // edx@78
  63.     int v64; // ecx@78
  64.     char v65; // al@78
  65.     unsigned int v66; // ecx@81
  66.     int v67; // edx@82
  67.     int v68; // ecx@82
  68.     char v69; // al@82
  69.     int v70; // ecx@87
  70.     int v71; // eax@90
  71.     int v72; // eax@96
  72.     int v73; // eax@98
  73.     int v74; // eax@100
  74.     int v75; // eax@101
  75.     int v76; // eax@104
  76.     int v77; // eax@106
  77.     int v78; // eax@107
  78.     int v79; // eax@109
  79.     int v80; // eax@111
  80.     int v81; // eax@112
  81.     int v82; // eax@119
  82.     int v83; // eax@121
  83.     int v84; // eax@123
  84.     int v85; // eax@125
  85.     char *v86; // [sp+14h] [bp-D04h]@11
  86.     int v87; // [sp+18h] [bp-D00h]@59
  87.     signed int v88; // [sp+1Ch] [bp-CFCh]@7
  88.     char *v89; // [sp+20h] [bp-CF8h]@59
  89.     signed int v90; // [sp+24h] [bp-CF4h]@52
  90.     char *v91; // [sp+28h] [bp-CF0h]@25
  91.     signed int v92; // [sp+2Ch] [bp-CECh]@20
  92.     char *v93; // [sp+30h] [bp-CE8h]@24
  93.     signed int v94; // [sp+34h] [bp-CE4h]@9
  94.     int v95; // [sp+38h] [bp-CE0h]@1
  95.     unsigned int v96; // [sp+3Ch] [bp-CDCh]@1
  96.     char *v97; // [sp+40h] [bp-CD8h]@8
  97.     int v98; // [sp+44h] [bp-CD4h]@1
  98.     int v99; // [sp+48h] [bp-CD0h]@1
  99.     char v100; // [sp+4Ch] [bp-CCCh]@1
  100.     char v101[3272]; // [sp+50h] [bp-CC8h]@7
  101.      
  102.     v95 = 0;
  103.     v4 = 0;
  104.     v96 = -1;
  105.     v99 = (int)((char *)output + output_size);
  106.     v98 = (int)input;
  107.     v100 = *(unsigned char *)input;
  108.     v5 = (*(unsigned char *)(input + 1) << 24) | (*(unsigned char *)(input + 2) << 16) | (*(unsigned char *)(input + 3) << 8) | *(unsigned char *)(input + 4);
  109.     if ( *(unsigned char *)input >= 0 )
  110.     {
  111.         memset(v101, 128, 0xCA8u);
  112.         v88 = 0;
  113.         while ( 1 )
  114.         {
  115.             while ( 1 )
  116.             {
  117.                 v97 = &v101[v95];
  118.                 v7 = (unsigned char)v101[v95 + 2920];
  119.                 if ( !(v96 >> 24) )
  120.                 {
  121.                     v71 = *(unsigned char *)(v98 + 5);
  122.                     v96 <<= 8;
  123.                     ++v98;
  124.                     v5 = (v5 << 8) + v71;
  125.                 }
  126.                 v8 = v7 - (v7 >> 3);
  127.                 v9 = v7 * (v96 >> 8);
  128.                 v94 = v5 < v9;
  129.                 if ( v5 < v9 )
  130.                     break;
  131.                 v96 -= v9;
  132.                 v5 -= v9;
  133.                 v97[2920] = v8;
  134.                 v95 = (v95 - 1) & ((unsigned __int64)~(v95 - 1) >> 32);
  135.                 if ( output == (void *)v99 )
  136.                     return -2;
  137.                 v86 = &v101[255 * ((((((unsigned char)output & 7) << 8) | v4 & 0xFFFFF8FFu) >> v100) & 7)];
  138.                 v4 = 1;
  139.                 do
  140.                 {
  141.                     v10 = (int)&v86[v4];
  142.                     v11 = (unsigned char)v86[v4 - 1];
  143.                     if ( !(v96 >> 24) )
  144.                     {
  145.                         v15 = *(unsigned char *)(v98++ + 5);
  146.                         v96 <<= 8;
  147.                         v5 = (v5 << 8) + v15;
  148.                     }
  149.                     v4 *= 2;
  150.                     v12 = v11 * (v96 >> 8);
  151.                     v13 = v11 - (v11 >> 3);
  152.                     v14 = v13;
  153.                     if ( v5 < (unsigned int)v12 )
  154.                     {
  155.                         v96 = v12;
  156.                         ++v4;
  157.                         v14 = v13 + 31;
  158.                     }
  159.                     else
  160.                     {
  161.                         v96 -= v12;
  162.                         v5 -= v12;
  163.                     }
  164.                     *(unsigned char *)(v10 - 1) = v14;
  165.                 }
  166.                 while ( v4 <= 255 );
  167.  
  168.                 output = (unsigned char *)output + 1;
  169.                 ++v88;
  170.                 *((unsigned char *)output - 1) = v4;
  171.             }
  172.             v96 = v7 * (v96 >> 8);
  173.             v97[2920] = v8 + 31;
  174.             v92 = -1;
  175.             while ( 1 )
  176.             {
  177.                 v16 = (unsigned char)v97[2928];
  178.                 if ( !(v9 >> 24) )
  179.                 {
  180.                     v80 = *(unsigned char *)(v98++ + 5);
  181.                     v96 = v9 << 8;
  182.                     v5 = (v5 << 8) + v80;
  183.                 }
  184.                 v97 += 8;
  185.                 v9 = v16 * (v96 >> 8);
  186.                 v17 = v16 - (v16 >> 3);
  187.                 if ( v5 >= v9 )
  188.                     break;
  189.                 v96 = v9;
  190.                 v97[2920] = v17 + 31;
  191.                 ++v92;
  192.                 if ( v92 == 6 )
  193.                     goto LABEL_24;
  194.             }
  195.             v96 -= v9;
  196.             v5 -= v9;
  197.             v97[2920] = v17;
  198.     LABEL_24:
  199.             v93 = &v101[v92];
  200.             if ( v92 >= 0 )
  201.             {
  202.                 v91 = &v101[v95 & 7 | 8 * (((unsigned int)output << v92) & 3) | 32 * v92];
  203.                 v18 = v92 - 3;
  204.                 v19 = (unsigned char)v91[2984];
  205.                 if ( !(v96 >> 24) )
  206.                 {
  207.                     v73 = *(unsigned char *)(v98++ + 5);
  208.                     v96 <<= 8;
  209.                     v5 = (v5 << 8) + v73;
  210.                 }
  211.                 v20 = v19 * (v96 >> 8);
  212.                 v21 = v19 - (v19 >> 3);
  213.                 v22 = v21;
  214.                 v23 = 2;
  215.                 if ( v5 >= (unsigned int)v20 )
  216.                 {
  217.                     v96 -= v20;
  218.                     v5 -= v20;
  219.                 }
  220.                 else
  221.                 {
  222.                     v96 = v20;
  223.                     v23 = 3;
  224.                     v22 = v21 + 31;
  225.                 }
  226.                 if ( v18 < 0 )
  227.                 {
  228.                     v91[2984] = v22;
  229.                 }
  230.                 else
  231.                 {
  232.                     if ( v18 <= 0 )
  233.                     {
  234.                         v91[2984] = v22;
  235.                     }
  236.                     else
  237.                     {
  238.                         v24 = (unsigned char)v22;
  239.                         if ( !(v96 >> 24) )
  240.                         {
  241.                             v83 = *(unsigned char *)(v98++ + 5);
  242.                             v96 <<= 8;
  243.                             v5 = (v5 << 8) + v83;
  244.                         }
  245.                         v23 *= 2;
  246.                         v25 = v24 * (v96 >> 8);
  247.                         v26 = v24 - (v24 >> 3);
  248.                         v27 = v26;
  249.                         if ( v5 >= (unsigned int)v25 )
  250.                         {
  251.                             v96 -= v25;
  252.                             v5 -= v25;
  253.                         }
  254.                         else
  255.                         {
  256.                             v96 = v25;
  257.                             ++v23;
  258.                             v27 = v26 + 31;
  259.                         }
  260.                         v91[2984] = v27;
  261.                         if ( v18 != 1 )
  262.                         {
  263.                             if ( !(v96 >> 24) )
  264.                             {
  265.                                 v81 = *(unsigned char *)(v98 + 5);
  266.                                 v96 <<= 8;
  267.                                 ++v98;
  268.                                 v5 = (v5 << 8) + v81;
  269.                             }
  270.                             do
  271.                             {
  272.                                 v96 >>= 1;
  273.                                 v23 = (v5 < v96) + 2 * v23;
  274.                                 if ( v5 >= v96 )
  275.                                     v5 -= v96;
  276.                                 --v18;
  277.                             }
  278.                             while ( v18 != 1 );
  279.                         }
  280.                     }
  281.                     v28 = (unsigned char)v91[3008];
  282.                     if ( !(v96 >> 24) )
  283.                     {
  284.                         v82 = *(unsigned char *)(v98 + 5);
  285.                         v96 <<= 8;
  286.                         ++v98;
  287.                         v5 = (v5 << 8) + v82;
  288.                     }
  289.                     v23 *= 2;
  290.                     v29 = v28 * (v96 >> 8);
  291.                     v30 = v28 - (v28 >> 3);
  292.                     v31 = v30;
  293.                     if ( v5 >= (unsigned int)v29 )
  294.                     {
  295.                         v96 -= v29;
  296.                         v5 -= v29;
  297.                     }
  298.                     else
  299.                     {
  300.                         v96 = v29;
  301.                         ++v23;
  302.                         v31 = v30 + 31;
  303.                     }
  304.                     v91[3008] = v31;
  305.                 }
  306.                 if ( v92 > 0 )
  307.                 {
  308.                     v32 = (unsigned char)v91[2992];
  309.                     if ( !(v96 >> 24) )
  310.                     {
  311.                         v85 = *(unsigned char *)(v98++ + 5);
  312.                         v96 <<= 8;
  313.                         v5 = (v5 << 8) + v85;
  314.                     }
  315.                     v23 *= 2;
  316.                     v33 = v32 * (v96 >> 8);
  317.                     v34 = v32 - (v32 >> 3);
  318.                     v35 = v34;
  319.                     if ( v5 >= (unsigned int)v33 )
  320.                     {
  321.                         v96 -= v33;
  322.                         v5 -= v33;
  323.                     }
  324.                     else
  325.                     {
  326.                         v96 = v33;
  327.                         ++v23;
  328.                         v35 = v34 + 31;
  329.                     }
  330.                     v91[2992] = v35;
  331.                     if ( v92 != 1 )
  332.                     {
  333.                         v36 = (unsigned char)v91[3000];
  334.                         if ( !(v96 >> 24) )
  335.                         {
  336.                             v84 = *(unsigned char *)(v98 + 5);
  337.                             v96 <<= 8;
  338.                             ++v98;
  339.                             v5 = (v5 << 8) + v84;
  340.                         }
  341.                         v23 *= 2;
  342.                         v37 = v36 * (v96 >> 8);
  343.                         v38 = v36 - (v36 >> 3);
  344.                         v39 = v38;
  345.                         if ( v5 >= (unsigned int)v37 )
  346.                         {
  347.                             v96 -= v37;
  348.                             v5 -= v37;
  349.                         }
  350.                         else
  351.                         {
  352.                             v96 = v37;
  353.                             ++v23;
  354.                             v39 = v38 + 31;
  355.                         }
  356.                         v91[3000] = v39;
  357.                     }
  358.                 }
  359.                 v94 = v23;
  360.                 if ( v23 == 255 )
  361.                     break;
  362.             }
  363.             v40 = 8;
  364.             v90 = 352;
  365.             if ( v94 <= 2 )
  366.             {
  367.                 v93 += 248;
  368.                 v90 = 64;
  369.             }
  370.             do
  371.             {
  372.                 v41 = (int)&v93[v40];
  373.                 if ( !(v96 >> 24) )
  374.                 {
  375.                     v72 = *(unsigned char *)(v98++ + 5);
  376.                     v96 <<= 8;
  377.                     v5 = (v5 << 8) + v72;
  378.                 }
  379.                 v42 = *(unsigned char *)(v41 + 2033);
  380.                 v40 *= 2;
  381.                 v43 = v42 * (v96 >> 8);
  382.                 v44 = v42 - (v42 >> 3);
  383.                 v45 = v44;
  384.                 if ( v5 < (unsigned int)v43 )
  385.                 {
  386.                     v96 = v43;
  387.                     v45 = v44 + 31;
  388.                     v40 += 8;
  389.                 }
  390.                 else
  391.                 {
  392.                     v96 -= v43;
  393.                     v5 -= v43;
  394.                 }
  395.                 *(unsigned char *)(v41 + 2033) = v45;
  396.                 v46 = v40 - v90;
  397.             }
  398.             while ( v40 - v90 < 0 );
  399.  
  400.             if ( v40 != v90 )
  401.             {
  402.                 v47 = v46 >> 3;
  403.                 v87 = v47 - 1;
  404.                 v48 = v47 - 4;
  405.                 v89 = &v101[32 * (v47 - 1)];
  406.                 v49 = (unsigned char)v89[2344];
  407.                 if ( !(v96 >> 24) )
  408.                 {
  409.                     v78 = *(unsigned char *)(v98 + 5);
  410.                     v96 <<= 8;
  411.                     ++v98;
  412.                     v5 = (v5 << 8) + v78;
  413.                 }
  414.                 v50 = v49 * (v96 >> 8);
  415.                 v51 = v49 - (v49 >> 3);
  416.                 v52 = v51;
  417.                 v53 = 2;
  418.                 if ( v5 >= (unsigned int)v50 )
  419.                 {
  420.                     v96 -= v50;
  421.                     v5 -= v50;
  422.                 }
  423.                 else
  424.                 {
  425.                     v96 = v50;
  426.                     v53 = 3;
  427.                     v52 = v51 + 31;
  428.                 }
  429.                 if ( v48 < 0 )
  430.                 {
  431.                     v89[2344] = v52;
  432.                 }
  433.                 else
  434.                 {
  435.                     if ( v48 <= 0 )
  436.                     {
  437.                         v89[2344] = v52;
  438.                     }
  439.                     else
  440.                     {
  441.                         v54 = (unsigned char)v52;
  442.                         if ( !(v96 >> 24) )
  443.                         {
  444.                             v79 = *(unsigned char *)(v98++ + 5);
  445.                             v96 <<= 8;
  446.                             v5 = (v5 << 8) + v79;
  447.                         }
  448.                         v53 *= 2;
  449.                         v55 = v54 * (v96 >> 8);
  450.                         v56 = v54 - (v54 >> 3);
  451.                         v57 = v56;
  452.                         if ( v5 >= (unsigned int)v55 )
  453.                         {
  454.                             v96 -= v55;
  455.                             v5 -= v55;
  456.                         }
  457.                         else
  458.                         {
  459.                             v96 = v55;
  460.                             ++v53;
  461.                             v57 = v56 + 31;
  462.                         }
  463.                         v89[2344] = v57;
  464.                         if ( v48 != 1 )
  465.                         {
  466.                             if ( !(v96 >> 24) )
  467.                             {
  468.                                 v75 = *(unsigned char *)(v98 + 5);
  469.                                 v96 <<= 8;
  470.                                 ++v98;
  471.                                 v5 = (v5 << 8) + v75;
  472.                             }
  473.                             do
  474.                             {
  475.                                 v96 >>= 1;
  476.                                 v53 = (v5 < v96) + 2 * v53;
  477.                                 if ( v5 >= v96 )
  478.                                     v5 -= v96;
  479.                                 --v48;
  480.                             }
  481.                             while ( v48 != 1 );
  482.                         }
  483.                     }
  484.                     v58 = (unsigned char)v89[2368];
  485.                     if ( !(v96 >> 24) )
  486.                     {
  487.                         v74 = *(unsigned char *)(v98 + 5);
  488.                         v96 <<= 8;
  489.                         ++v98;
  490.                         v5 = (v5 << 8) + v74;
  491.                     }
  492.                     v53 *= 2;
  493.                     v59 = v58 * (v96 >> 8);
  494.                     v60 = v58 - (v58 >> 3);
  495.                     v61 = v60;
  496.                     if ( v5 >= (unsigned int)v59 )
  497.                     {
  498.                         v96 -= v59;
  499.                         v5 -= v59;
  500.                     }
  501.                     else
  502.                     {
  503.                         v96 = v59;
  504.                         ++v53;
  505.                         v61 = v60 + 31;
  506.                     }
  507.                     v89[2368] = v61;
  508.                 }
  509.                 if ( v87 > 0 )
  510.                 {
  511.                     v62 = (unsigned char)v89[2352];
  512.                     if ( !(v96 >> 24) )
  513.                     {
  514.                         v77 = *(unsigned char *)(v98++ + 5);
  515.                         v96 <<= 8;
  516.                         v5 = (v5 << 8) + v77;
  517.                     }
  518.                     v53 *= 2;
  519.                     v63 = v62 * (v96 >> 8);
  520.                     v64 = v62 - (v62 >> 3);
  521.                     v65 = v64;
  522.                     if ( v5 >= (unsigned int)v63 )
  523.                     {
  524.                         v96 -= v63;
  525.                         v5 -= v63;
  526.                     }
  527.                     else
  528.                     {
  529.                         v96 = v63;
  530.                         ++v53;
  531.                         v65 = v64 + 31;
  532.                     }
  533.                     v89[2352] = v65;
  534.                     if ( v87 != 1 )
  535.                     {
  536.                         v66 = (unsigned char)v89[2360];
  537.                         if ( !(v96 >> 24) )
  538.                         {
  539.                             v76 = *(unsigned char *)(v98 + 5);
  540.                             v96 <<= 8;
  541.                             ++v98;
  542.                             v5 = (v5 << 8) + v76;
  543.                         }
  544.                         v53 *= 2;
  545.                         v67 = v66 * (v96 >> 8);
  546.                         v68 = v66 - (v66 >> 3);
  547.                         v69 = v68;
  548.                         if ( v5 >= (unsigned int)v67 )
  549.                         {
  550.                             v96 -= v67;
  551.                             v5 -= v67;
  552.                         }
  553.                         else
  554.                         {
  555.                             v96 = v67;
  556.                             ++v53;
  557.                             v69 = v68 + 31;
  558.                         }
  559.                         v89[2360] = v69;
  560.                     }
  561.                 }
  562.                 v46 = v53 - 1;
  563.             }
  564.             if ( v88 <= (unsigned int)v46 )
  565.                 return -1;
  566.  
  567.             *((unsigned char*)&(v4)) = *((unsigned char *)output + -v46 - 1);
  568.             v70 = (int)((char *)output + v94);
  569.             v95 = (((unsigned char)v94 + (unsigned char)output) & 1) + 6;
  570.             if ( (unsigned int)((char *)output + v94) >= v99 )
  571.                 return -2;
  572.  
  573.             do
  574.             {
  575.                 output = (unsigned char *)output + 1;
  576.                 ++v88;
  577.                 *((unsigned char *)output - 1) = v4;
  578.                 v4 = *((unsigned char *)output + -v46 - 1);
  579.             }
  580.             while ( output != (void *)v70 );
  581.  
  582.             output = (unsigned char *)output + 1;
  583.             ++v88;
  584.             *((unsigned char *)output - 1) = v4;
  585.         }
  586.         if ( input_end )
  587.             *(unsigned int *)input_end = v98 + 5;
  588.         result = v88;
  589.     }
  590.     else
  591.     {
  592.         result = -2;
  593.         if ( v5 <= output_size )
  594.         {
  595.             memcpy(output, (const void *)(input + 5), v5);
  596.             if ( input_end )
  597.                 *(unsigned int *)input_end = (unsigned int)(input + v5 + 5);
  598.             result = v5;
  599.         }
  600.     }
  601.     return result;
  602. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!