Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Dec 16th, 2011  |  syntax: C  |  size: 12.70 KB  |  views: 247  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  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. }