LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: AddWeighedStatFreqs
static void AddWeighedStatFreqs(const SymbolStats* stats1, double w1,
                                const SymbolStats* stats2, double w2,
                                SymbolStats* result) {
  size_t i;
  for (i = 0; i < 288; i++) {
    result->litlens[i] =
        (size_t) (stats1->litlens[i] * w1 + stats2->litlens[i] * w2);
  }
  for (i = 0; i < 32; i++) {
    result->dists[i] =
        (size_t) (stats1->dists[i] * w1 + stats2->dists[i] * w2);
  }
  result->litlens[256] = 1;  /* End symbol. */
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq %rdx, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
cmpq $0x120, -0x30(%rsp)     # imm = 0x120
jae 0x9b50
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %xmm0
movaps 0x3807(%rip), %xmm4     # 0xd2c0
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x380b(%rip), %xmm3     # 0xd2d0
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd -0x10(%rsp), %xmm2
movq -0x18(%rsp), %rax
movq (%rax,%rcx,8), %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
movsd -0x20(%rsp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
movq %rdx, %rcx
sarq $0x3f, %rcx
movsd 0x4218(%rip), %xmm1     # 0xdd38
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rdx
movq -0x28(%rsp), %rax
movq -0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x9a94
movq $0x0, -0x30(%rsp)
cmpq $0x20, -0x30(%rsp)
jae 0x9c1e
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq 0x900(%rax,%rcx,8), %xmm0
movaps 0x3741(%rip), %xmm4     # 0xd2c0
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x3745(%rip), %xmm3     # 0xd2d0
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd -0x10(%rsp), %xmm2
movq -0x18(%rsp), %rax
movq 0x900(%rax,%rcx,8), %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
movsd -0x20(%rsp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
movq %rdx, %rcx
sarq $0x3f, %rcx
movsd 0x414e(%rip), %xmm1     # 0xdd38
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rdx
movq -0x28(%rsp), %rax
movq -0x30(%rsp), %rcx
movq %rdx, 0x900(%rax,%rcx,8)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x9b59
movq -0x28(%rsp), %rax
movq $0x1, 0x800(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: ZopfliLZ77OptimalFixed
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
                            const unsigned char* in,
                            size_t instart, size_t inend,
                            ZopfliLZ77Store* store)
{
  /* Dist to get to here with smallest cost. */
  size_t blocksize = inend - instart;
  unsigned short* length_array =
      (unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
  unsigned short* path = 0;
  size_t pathsize = 0;

  if (!length_array) exit(-1); /* Allocation failed. */

  s->blockstart = instart;
  s->blockend = inend;

  /* Shortest path for fixed tree This one should give the shortest possible
  result for fixed tree, no repeated runs are needed since the tree is known. */
  LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
                 length_array, GetCostFixed, 0, store);

  free(length_array);
  free(path);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x50(%rsp), %rax
subq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $0x1, %rdi
shlq %rdi
callq 0x1120
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x9d37
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1170
movq 0x58(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x38(%rsp), %r11
movq 0x48(%rsp), %rax
leaq 0x30(%rsp), %r8
leaq 0x28(%rsp), %r9
leaq 0x3e(%rip), %r10        # 0x9dc0
xorl %ebx, %ebx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x9780
movq 0x38(%rsp), %rdi
callq 0x1030
movq 0x30(%rsp), %rdi
callq 0x1030
addq $0x70, %rsp
popq %rbx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: GetCostFixed
static double GetCostFixed(unsigned litlen, unsigned dist, void* unused) {
  (void)unused;
  if (dist == 0) {
    if (litlen <= 143) return 8;
    else return 9;
  } else {
    int dbits = ZopfliGetDistExtraBits(dist);
    int lbits = ZopfliGetLengthExtraBits(litlen);
    int lsym = ZopfliGetLengthSymbol(litlen);
    double cost = 0;
    if (lsym <= 279) cost += 7;
    else cost += 8;
    cost += 5;  /* Every dist symbol has length 5. */
    return cost + dbits + lbits;
  }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpl $0x0, 0x28(%rsp)
jne 0x9e08
cmpl $0x8f, 0x2c(%rsp)
ja 0x9df5
movsd 0x3f56(%rip), %xmm0     # 0xdd40
movsd %xmm0, 0x30(%rsp)
jmp 0x9ea0
movsd 0x3f5b(%rip), %xmm0     # 0xdd58
movsd %xmm0, 0x30(%rsp)
jmp 0x9ea0
movl 0x28(%rsp), %edi
callq 0xb360
movl %eax, 0x1c(%rsp)
movl 0x2c(%rsp), %edi
callq 0xb460
movl %eax, 0x18(%rsp)
movl 0x2c(%rsp), %edi
callq 0xb4a0
movl %eax, 0x14(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpl $0x117, 0x14(%rsp)      # imm = 0x117
jg 0x9e58
movsd 0x3efe(%rip), %xmm0     # 0xdd48
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x9e6c
movsd 0x3ee0(%rip), %xmm0     # 0xdd40
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x3edc(%rip), %xmm0     # 0xdd50
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: GetCostModelMinCost
static double GetCostModelMinCost(CostModelFun* costmodel, void* costcontext) {
  double mincost;
  int bestlength = 0; /* length that has lowest cost in the cost model */
  int bestdist = 0; /* distance that has lowest cost in the cost model */
  int i;
  /*
  Table of distances that have a different distance symbol in the deflate
  specification. Each value is the first distance that has a new symbol. Only
  different symbols affect the cost model so only these need to be checked.
  See RFC 1951 section 3.2.5. Compressed blocks (length and distance codes).
  */
  static const int dsymbols[30] = {
    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
    769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
  };

  mincost = ZOPFLI_LARGE_FLOAT;
  for (i = 3; i < 259; i++) {
    double c = costmodel(i, 1, costcontext);
    if (c < mincost) {
      bestlength = i;
      mincost = c;
    }
  }

  mincost = ZOPFLI_LARGE_FLOAT;
  for (i = 0; i < 30; i++) {
    double c = costmodel(3, dsymbols[i], costcontext);
    if (c < mincost) {
      bestdist = dsymbols[i];
      mincost = c;
    }
  }

  return costmodel(bestlength, bestdist, costcontext);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movsd 0x2332(%rip), %xmm0     # 0xd008
movsd %xmm0, 0x20(%rsp)
movl $0x3, 0x14(%rsp)
cmpl $0x103, 0x14(%rsp)      # imm = 0x103
jge 0xad3e
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %edi
movq 0x28(%rsp), %rdx
movl $0x1, %esi
callq *%rax
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xad2f
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0xad31
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xace4
movsd 0x22c2(%rip), %xmm0     # 0xd008
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x1e, 0x14(%rsp)
jge 0xadbe
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rdx
leaq 0x3304(%rip), %rcx      # 0xe070
movl (%rcx,%rdx,4), %esi
movq 0x28(%rsp), %rdx
movl $0x3, %edi
callq *%rax
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xadaf
movslq 0x14(%rsp), %rcx
leaq 0x32d3(%rip), %rax      # 0xe070
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0xadb1
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xad54
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x28(%rsp), %rdx
callq *%rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/util.c
// Function: ZopfliGetDistExtraBitsValue
int ZopfliGetDistExtraBitsValue(int dist) {
#ifdef __GNUC__
  if (dist < 5) {
    return 0;
  } else {
    int l = 31 ^ __builtin_clz(dist - 1); /* log2(dist - 1) */
    return (dist - (1 + (1 << l))) & ((1 << (l - 1)) - 1);
  }
#else
  if (dist < 5) return 0;
  else if (dist < 9) return (dist - 5) & 1;
  else if (dist < 17) return (dist - 9) & 3;
  else if (dist < 33) return (dist - 17) & 7;
  else if (dist < 65) return (dist - 33) & 15;
  else if (dist < 129) return (dist - 65) & 31;
  else if (dist < 257) return (dist - 129) & 63;
  else if (dist < 513) return (dist - 257) & 127;
  else if (dist < 1025) return (dist - 513) & 255;
  else if (dist < 2049) return (dist - 1025) & 511;
  else if (dist < 4097) return (dist - 2049) & 1023;
  else if (dist < 8193) return (dist - 4097) & 2047;
  else if (dist < 16385) return (dist - 8193) & 4095;
  else return (dist - 16385) & 8191;
#endif
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x5, -0x8(%rsp)
jge 0xb3b5
movl $0x0, -0x4(%rsp)
jmp 0xb3f8
movl -0x8(%rsp), %eax
subl $0x1, %eax
bsrl %eax, %eax
xorl $0x1f, %eax
xorl $0x1f, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
movl -0xc(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zlib_container.c
// Function: adler32
static unsigned adler32(const unsigned char* data, size_t size)
{
  static const unsigned sums_overflow = 5550;
  unsigned s1 = 1;
  unsigned s2 = 1 >> 16;

  while (size > 0) {
    size_t amount = size > sums_overflow ? sums_overflow : size;
    size -= amount;
    while (amount > 0) {
      s1 += (*data++);
      s2 += s1;
      amount--;
    }
    s1 %= 65521;
    s2 %= 65521;
  }

  return (s2 << 16) | s1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
jbe 0xbbca
cmpq $0x15ae, -0x10(%rsp)    # imm = 0x15AE
jbe 0xbb3d
movl $0x15ae, %eax           # imm = 0x15AE
movq %rax, -0x28(%rsp)
jmp 0xbb47
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x20(%rsp)
jbe 0xbba3
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movzbl (%rax), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xbb63
movl -0x14(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x14(%rsp)
movl -0x18(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x18(%rsp)
jmp 0xbb1a
movl -0x18(%rsp), %eax
shll $0x10, %eax
orl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_bin.c
// Function: AddStrings
static char* AddStrings(const char* str1, const char* str2) {
  size_t len = strlen(str1) + strlen(str2);
  char* result = (char*)malloc(len + 1);
  if (!result) exit(-1); /* Allocation failed. */
  strcpy(result, str1);
  strcat(result, str2);
  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x1080
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq 0x1120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc10a
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1170
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1040
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1160
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_bin.c
// Function: CompressFile
static void CompressFile(const ZopfliOptions* options,
                         ZopfliFormat output_type,
                         const char* infilename,
                         const char* outfilename) {
  unsigned char* in;
  size_t insize;
  unsigned char* out = 0;
  size_t outsize = 0;
  LoadFile(infilename, &in, &insize);
  if (insize == 0) {
    fprintf(stderr, "Invalid filename: %s\n", infilename);
    return;
  }

  ZopfliCompress(options, output_type, in, insize, &out, &outsize);

  if (outfilename) {
    SaveFile(outfilename, out, outsize);
  } else {
    size_t i;
    for (i = 0; i < outsize; i++) {
      /* Works only if terminal does not convert newlines. */
      printf("%c", out[i]);
    }
  }

  free(out);
  free(in);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xc240
cmpq $0x0, 0x18(%rsp)
jne 0xc1a7
movq 0x5e6c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0x3036(%rip), %rsi      # 0xf1d1
movb $0x0, %al
callq 0x10f0
jmp 0xc239
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
callq 0xc460
cmpq $0x0, 0x28(%rsp)
je 0xc1e7
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xc390
jmp 0xc225
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0xc223
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2fd9(%rip), %rdi      # 0xf1e7
movb $0x0, %al
callq 0x1090
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xc1ef
jmp 0xc225
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_bin.c
// Function: LoadFile
static void LoadFile(const char* filename,
                     unsigned char** out, size_t* outsize) {
  FILE* file;

  *out = 0;
  *outsize = 0;
  file = fopen(filename, "rb");
  if (!file) return;

  fseek(file , 0 , SEEK_END);
  *outsize = ftell(file);
  rewind(file);

  *out = (unsigned char*)malloc(*outsize);

  if (*outsize && (*out)) {
    size_t testsize = fread(*out, 1, *outsize, file);
    if (testsize != *outsize) {
      /* It could be a directory */
      free(*out);
      *out = 0;
      *outsize = 0;
    }
  }

  assert(!(*outsize) || out);  /* If size is not zero, out must be allocated. */
  fclose(file);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rdi
leaq 0x2f73(%rip), %rsi      # 0xf1ea
callq 0x1150
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc28e
jmp 0xc384
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1130
movq 0x8(%rsp), %rdi
callq 0x1100
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x10a0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1120
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc346
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc346
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
je 0xc344
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
jmp 0xc346
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc359
cmpq $0x0, 0x18(%rsp)
je 0xc35b
jmp 0xc37a
leaq 0x2e8b(%rip), %rdi      # 0xf1ed
leaq 0x2dfd(%rip), %rsi      # 0xf166
movl $0x40, %edx
leaq 0x2e8b(%rip), %rcx      # 0xf200
callq 0x10b0
movq 0x8(%rsp), %rdi
callq 0x1070
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_bin.c
// Function: SaveFile
static void SaveFile(const char* filename,
                     const unsigned char* in, size_t insize) {
  FILE* file = fopen(filename, "wb" );
  assert(file);
  fwrite((char*)in, 1, insize, file);
  fclose(file);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x2e89(%rip), %rsi      # 0xf238
callq 0x1150
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc3c3
jmp 0xc3e2
leaq 0x2e71(%rip), %rdi      # 0xf23b
leaq 0x2d95(%rip), %rsi      # 0xf166
movl $0x4a, %edx
leaq 0x2e63(%rip), %rcx      # 0xf240
callq 0x10b0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x1180
movq 0x8(%rsp), %rdi
callq 0x1070
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_lib.c
// Function: ZopfliInitOptions
void ZopfliInitOptions(ZopfliOptions* options) {
  options->verbose = 0;
  options->numiterations = 15;
  options->blocksplitting = 1;
  options->blocksplittinglast = 0;
  options->blocksplittingmax = 15;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0xf, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movl $0xf, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/imaya[P]zopfli-for-emscripten/zopfli_lib.c
// Function: ZopfliCompress
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
                    const unsigned char* in, size_t insize,
                    unsigned char** out, size_t* outsize)
{
  if (output_type == ZOPFLI_FORMAT_GZIP) {
    ZopfliGzipCompress(options, in, insize, out, outsize);
  } else if (output_type == ZOPFLI_FORMAT_ZLIB) {
    ZopfliZlibCompress(options, in, insize, out, outsize);
  } else if (output_type == ZOPFLI_FORMAT_DEFLATE) {
    unsigned char bp = 0;
    ZopfliDeflate(options, 2 /* Dynamic block */, 1,
                  in, insize, &bp, out, outsize);
  } else {
    assert(0);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0xc4ab
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x5a40
jmp 0xc539
cmpl $0x1, 0x3c(%rsp)
jne 0xc4d2
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xb4c0
jmp 0xc537
cmpl $0x2, 0x3c(%rsp)
jne 0xc516
movb $0x0, 0x17(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %rax
movl $0x2, %esi
movl $0x1, %edx
leaq 0x17(%rsp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x34d0
jmp 0xc535
leaq 0x1a77(%rip), %rdi      # 0xdf94
leaq 0x2d57(%rip), %rsi      # 0xf27b
movl $0x23, %edx
leaq 0x2d58(%rip), %rcx      # 0xf288
callq 0x10b0
jmp 0xc537
jmp 0xc539
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/page_fault1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long pgsize = getpagesize();

	while (1) {
		unsigned long i;

		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
		assert(c != MAP_FAILED);

		for (i = 0; i < MEMSIZE; i += pgsize) {
			c[i] = 0;
			(*iterations)++;
		}

		munmap(c, MEMSIZE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2260
cltq
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %r9d
movl $0x8000000, %esi        # imm = 0x8000000
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
je 0x3000
jmp 0x301f
leaq 0x127d(%rip), %rdi      # 0x4284
leaq 0x1286(%rip), %rsi      # 0x4294
movl $0x13, %edx
leaq 0x128e(%rip), %rcx      # 0x42a8
callq 0x2110
movq $0x0, -0x20(%rbp)
cmpq $0x8000000, -0x20(%rbp) # imm = 0x8000000
jae 0x3059
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3027
movq -0x28(%rbp), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x21c0
jmp 0x2fcb
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: randombytes
void randombytes(uint8_t *x, size_t how_much) {
  ssize_t i;
  static int fd = -1;

  ssize_t xlen = (ssize_t)how_much;
  assert(xlen >= 0);
  if (fd == -1) {
    for (;;) {
      fd = open("/dev/urandom", O_RDONLY);
      if (fd != -1)
        break;
      sleep(1);
    }
  }

  while (xlen > 0) {
    if (xlen < 1048576)
      i = xlen;
    else
      i = 1048576;

    i = read(fd, x, (size_t)i);
    if (i < 1) {
      sleep(1);
      continue;
    }

    x += i;
    xlen -= i;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0x1202
jmp 0x1221
leaq 0x27e97(%rip), %rdi     # 0x290a0
leaq 0x27e9a(%rip), %rsi     # 0x290aa
movl $0xec, %edx
leaq 0x27e9b(%rip), %rcx     # 0x290b7
callq 0x1070
cmpl $-0x1, 0x29e58(%rip)    # 0x2b080
jne 0x125b
jmp 0x122c
leaq 0x27ea8(%rip), %rdi     # 0x290db
xorl %esi, %esi
movb $0x0, %al
callq 0x10b0
movl %eax, 0x29e3e(%rip)     # 0x2b080
cmpl $-0x1, 0x29e37(%rip)    # 0x2b080
je 0x124d
jmp 0x1259
movl $0x1, %edi
callq 0x10d0
jmp 0x122c
jmp 0x125b
jmp 0x125d
cmpq $0x0, 0x8(%rsp)
jle 0x12d6
cmpq $0x100000, 0x8(%rsp)    # imm = 0x100000
jge 0x127c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1285
movq $0x100000, 0x10(%rsp)   # imm = 0x100000
movl 0x29df5(%rip), %edi     # 0x2b080
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1090
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jge 0x12b3
movl $0x1, %edi
callq 0x10d0
jmp 0x125d
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x125d
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: dudect_main
dudect_state_t dudect_main(dudect_ctx_t *ctx) {
  prepare_inputs(ctx->config, ctx->input_data, ctx->classes);
  measure(ctx);

  bool first_time = ctx->percentiles[DUDECT_NUMBER_PERCENTILES - 1] == 0;

  dudect_state_t ret = DUDECT_NO_LEAKAGE_EVIDENCE_YET;
  if (first_time) {
    // throw away the first batch of measurements.
    // this helps warming things up.
    prepare_percentiles(ctx);
  } else {
    update_statistics(ctx);
    ret = report(ctx);
  }

  return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x1390
movq 0x10(%rsp), %rdi
callq 0x1440
movq 0x10(%rsp), %rax
movq 0x358(%rax), %rax
cmpq $0x0, 0x318(%rax)
sete %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movl $0x1, 0x8(%rsp)
testb $0x1, 0xf(%rsp)
je 0x136b
movq 0x10(%rsp), %rdi
callq 0x1520
jmp 0x1383
movq 0x10(%rsp), %rdi
callq 0x1620
movq 0x10(%rsp), %rdi
callq 0x17a0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: prepare_inputs
void prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {
  randombytes(input_data, c->number_measurements * c->chunk_size);
  for (size_t i = 0; i < c->number_measurements; i++) {
    classes[i] = randombit();
    if (classes[i] == 0) {
      memset(input_data + (size_t)i * c->chunk_size, 0x00, c->chunk_size);
    } else {
      // leave random
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rax
imulq (%rax), %rsi
callq 0x11e0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x143a
callq 0x12e0
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1426
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq (%rcx), %rax
addq %rax, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
xorl %esi, %esi
callq 0x1080
jmp 0x1428
jmp 0x1428
jmp 0x142a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x13c8
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: measure
static void measure(dudect_ctx_t *ctx) {
  for (size_t i = 0; i < ctx->config->number_measurements; i++) {
    ctx->ticks[i] = cpucycles();
    do_one_computation(ctx->input_data + i * ctx->config->chunk_size);
  }

  for (size_t i = 0; i < ctx->config->number_measurements-1; i++) {
    ctx->exec_times[i] = ctx->ticks[i+1] - ctx->ticks[i];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14b2
callq 0x1dd0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
imulq (%rcx), %rax
addq %rax, %rdi
callq 0x1cb0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1452
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1514
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
subq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x14ba
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: prepare_percentiles
static void prepare_percentiles(dudect_ctx_t *ctx) {
  qsort(ctx->exec_times, ctx->config->number_measurements, sizeof(int64_t), (int (*)(const void *, const void *))cmp);
  for (size_t i = 0; i < DUDECT_NUMBER_PERCENTILES; i++) {
    ctx->percentiles[i] = percentile(
        ctx->exec_times, 1 - (pow(0.5, 10 * (double)(i + 1) / DUDECT_NUMBER_PERCENTILES)),
        ctx->config->number_measurements);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
movl $0x8, %edx
leaq 0x895(%rip), %rcx       # 0x1de0
callq 0x1040
movq $0x0, 0x8(%rsp)
cmpq $0x64, 0x8(%rsp)
jae 0x1616
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
incq %rax
movq %rax, %xmm0
movaps 0x27aca(%rip), %xmm1    # 0x29050
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x27ace(%rip), %xmm1    # 0x29060
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x27a77(%rip), %xmm1    # 0x29020
mulsd %xmm0, %xmm1
movsd 0x27a63(%rip), %xmm0    # 0x29018
divsd %xmm0, %xmm1
movsd 0x27a4f(%rip), %xmm0    # 0x29010
callq 0x1050
movq (%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x27a33(%rip), %xmm0    # 0x29008
subsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x1e30
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x358(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1559
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: update_statistics
static void update_statistics(dudect_ctx_t *ctx) {
  for (size_t i = 10 /* discard the first few measurements */; i < (ctx->config->number_measurements-1); i++) {
    int64_t difference = ctx->exec_times[i];

    if (difference < 0) {
      continue; // the cpu cycle counter overflowed, just throw away the measurement
    }

    // t-test on the execution time
    t_push(ctx->ttest_ctxs[0], difference, ctx->classes[i]);

    // t-test on cropped execution times, for several cropping thresholds.
    for (size_t crop_index = 0; crop_index < DUDECT_NUMBER_PERCENTILES; crop_index++) {
      if (difference < ctx->percentiles[crop_index]) {
        t_push(ctx->ttest_ctxs[crop_index + 1], difference, ctx->classes[i]);
      }
    }

    // second-order test (only if we have more than 10000 measurements).
    // Centered product pre-processing.
    if (ctx->ttest_ctxs[0]->n[0] > 10000) {
      double centered = (double)difference - ctx->ttest_ctxs[0]->mean[ctx->classes[i]];
      t_push(ctx->ttest_ctxs[1 + DUDECT_NUMBER_PERCENTILES], centered * centered, ctx->classes[i]);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0xa, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1792
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jge 0x1675
jmp 0x177f
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
cvtsi2sdq 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x1ef0
movq $0x0, 0x8(%rsp)
cmpq $0x64, 0x8(%rsp)
jae 0x1708
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x358(%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x16f6
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
cvtsi2sdq 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x1ef0
jmp 0x16f8
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x16a5
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movsd 0x20(%rax), %xmm0
movsd 0x2790a(%rip), %xmm1    # 0x29028
ucomisd %xmm1, %xmm0
jbe 0x177d
cvtsi2sdq 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rax
movq 0x350(%rax), %rdi
movsd (%rsp), %xmm0
mulsd (%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x1ef0
jmp 0x177f
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1632
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: t_init
static void t_init(ttest_ctx_t *ctx) {
  for (int clazz = 0; clazz < 2; clazz ++) {
    ctx->mean[clazz] = 0.0;
    ctx->m2[clazz] = 0.0;
    ctx->n[clazz] = 0.0;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x2, -0xc(%rsp)
jge 0x1c09
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax,%rcx,8)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1bbd
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: dudect_free
int dudect_free(dudect_ctx_t *ctx)
{
  for (int i = 0; i < DUDECT_TESTS; i++) {
    free(ctx->ttest_ctxs[i]);
  }
  free(ctx->percentiles);
  free(ctx->input_data);
  free(ctx->classes);
  free(ctx->exec_times);
  free(ctx->ticks);
  free(ctx->config);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x66, 0xc(%rsp)
jge 0x1c49
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c21
movq 0x10(%rsp), %rax
movq 0x358(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t in[16] = {0};
  uint8_t out[16] = {0};
  uint8_t key[16] = {0x01,0};
  uint8_t ret = 0;

  memcpy(in, data, 16);
  crypto_stream(out, 16, in, key);
  ret ^= out[0];
  return ret;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
movq 0x2739e(%rip), %rax     # 0x29080
movq %rax, 0x10(%rsp)
movq 0x2739a(%rip), %rax     # 0x29088
movq %rax, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl $0x10, %esi
callq 0x1bac0
movzbl 0x20(%rsp), %ecx
movzbl 0xf(%rsp), %eax
xorl %ecx, %eax
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: main
int main(int argc, char **argv)
{
  (void)argc;
  (void)argv;

  dudect_config_t config = {
     .chunk_size = 16,
     .number_measurements = 1e6,
  };
  dudect_ctx_t ctx;

  dudect_init(&ctx, &config);

  dudect_state_t state = DUDECT_NO_LEAKAGE_EVIDENCE_YET;
  while (state == DUDECT_NO_LEAKAGE_EVIDENCE_YET) {
    state = dudect_main(&ctx);
  }
  dudect_free(&ctx);
  return (int)state;
}

// Assembly:
subq $0x388, %rsp            # imm = 0x388
movl $0x0, 0x384(%rsp)
movl %edi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq 0x27328(%rip), %rax     # 0x29090
movq %rax, 0x368(%rsp)
movq 0x27321(%rip), %rax     # 0x29098
movq %rax, 0x370(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x368(%rsp), %rsi
callq 0x1930
movl $0x1, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0x1db0
leaq 0x8(%rsp), %rdi
callq 0x1300
movl %eax, 0x4(%rsp)
jmp 0x1d99
leaq 0x8(%rsp), %rdi
callq 0x1c10
movl 0x4(%rsp), %eax
addq $0x388, %rsp            # imm = 0x388
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: t_push
static void t_push(ttest_ctx_t *ctx, double x, uint8_t clazz) {
  assert(clazz == 0 || clazz == 1);
  ctx->n[clazz]++;
  /*
   estimate variance on the fly as per the Welford method.
   this gives good numerical stability, see Knuth's TAOCP vol 2
  */
  double delta = x - ctx->mean[clazz];
  ctx->mean[clazz] = ctx->mean[clazz] + delta / ctx->n[clazz];
  ctx->m2[clazz] = ctx->m2[clazz] + delta * (x - ctx->mean[clazz]);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
je 0x1f1a
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x1f1c
jmp 0x1f3b
leaq 0x27298(%rip), %rdi     # 0x291bb
leaq 0x27180(%rip), %rsi     # 0x290aa
movl $0xae, %edx
leaq 0x2729e(%rip), %rcx     # 0x291d4
callq 0x1070
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
movsd 0x270bb(%rip), %xmm0    # 0x29008
addsd 0x20(%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rax,%rcx,8)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0x8(%rsp), %xmm1
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
divsd 0x20(%rax,%rcx,8), %xmm1
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
movsd 0x10(%rax,%rcx,8), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
subsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movzbl 0x17(%rsp), %ecx
movsd %xmm0, 0x10(%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: max_test
static ttest_ctx_t *max_test(dudect_ctx_t *ctx) {
  size_t ret = 0;
  double max = 0;
  for (size_t i = 0; i < DUDECT_TESTS; i++) {
    if (ctx->ttest_ctxs[i]->n[0] > DUDECT_ENOUGH_MEASUREMENTS) {
      double x = fabs(t_compute(ctx->ttest_ctxs[i]));
      if (max < x) {
        max = x;
        ret = i;
      }
    }
  }
  return ctx->ttest_ctxs[ret];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x66, 0x8(%rsp)
jae 0x20b3
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rax
movsd 0x20(%rax), %xmm0
movsd 0x26fdc(%rip), %xmm1    # 0x29028
ucomisd %xmm1, %xmm0
jbe 0x209e
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rdi
callq 0x20d0
movaps 0x27003(%rip), %xmm1    # 0x29070
pand %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x209c
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x209e
jmp 0x20a0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2024
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/src/dudect.h
// Function: t_compute
static double t_compute(ttest_ctx_t *ctx) {
  double var[2] = {0.0, 0.0};
  var[0] = ctx->m2[0] / (ctx->n[0] - 1);
  var[1] = ctx->m2[1] / (ctx->n[1] - 1);
  double num = (ctx->mean[0] - ctx->mean[1]);
  double den = sqrt(var[0] / ctx->n[0] + var[1] / ctx->n[1]);
  double t_value = num / den;
  return t_value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
movq 0x30(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd 0x20(%rax), %xmm1
movsd 0x26f02(%rip), %xmm2    # 0x29008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd 0x28(%rax), %xmm1
movsd 0x26ed8(%rip), %xmm2    # 0x29008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
divsd 0x20(%rax), %xmm0
movsd 0x28(%rsp), %xmm1
movq 0x30(%rsp), %rax
divsd 0x28(%rax), %xmm1
addsd %xmm1, %xmm0
callq 0x10c0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/common_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_load32_bigendian
uint32 load32_bigendian(const unsigned char *x)
{
  return
      (uint32) (x[3]) \
  | (((uint32) (x[2])) << 8) \
  | (((uint32) (x[1])) << 16) \
  | (((uint32) (x[0])) << 24)
  ;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x3(%rax), %eax
movq -0x8(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/common_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_store32_bigendian
void store32_bigendian(unsigned char *x,uint32 u)
{
  x[3] = u; u >>= 8;
  x[2] = u; u >>= 8;
  x[1] = u; u >>= 8;
  x[0] = u;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/common_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_load64_littleendian
uint64 load64_littleendian(const unsigned char *x)
{
  return
      (uint64) (x[0]) \
  | (((uint64) (x[1])) << 8) \
  | (((uint64) (x[2])) << 16) \
  | (((uint64) (x[3])) << 24)
  | (((uint64) (x[4])) << 32)
  | (((uint64) (x[5])) << 40)
  | (((uint64) (x[6])) << 48)
  | (((uint64) (x[7])) << 56)
  ;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/common_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_store64_littleendian
void store64_littleendian(unsigned char *x,uint64 u)
{
  x[0] = u; u >>= 8;
  x[1] = u; u >>= 8;
  x[2] = u; u >>= 8;
  x[3] = u; u >>= 8;
  x[4] = u; u >>= 8;
  x[5] = u; u >>= 8;
  x[6] = u; u >>= 8;
  x[7] = u;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_shufb
void shufb(int128 *r, const unsigned char *l)
{
  int128   t;
  uint8_t *ct;
  uint8_t *cr;

  copy2(&t, r);
  cr = r->u8;
  ct = t.u8;
  cr[0] = ct[l[0]];
  cr[1] = ct[l[1]];
  cr[2] = ct[l[2]];
  cr[3] = ct[l[3]];
  cr[4] = ct[l[4]];
  cr[5] = ct[l[5]];
  cr[6] = ct[l[6]];
  cr[7] = ct[l[7]];
  cr[8] = ct[l[8]];
  cr[9] = ct[l[9]];
  cr[10] = ct[l[10]];
  cr[11] = ct[l[11]];
  cr[12] = ct[l[12]];
  cr[13] = ct[l[13]];
  cr[14] = ct[l[14]];
  cr[15] = ct[l[15]];
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1b560
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x4(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x5(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x6(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x8(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0x9(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xa(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xc(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xc(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xd(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xd(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xe(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xe(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl 0xf(%rcx), %ecx
movb (%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0xf(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)