LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ndsol[P]git-mine/./blake2-impl.h
// Function: store32(void*, unsigned int)
static BLAKE2_INLINE void store32( void *dst, uint32_t w )
{
#if defined(NATIVE_LITTLE_ENDIAN)
  memcpy(dst, &w, sizeof w);
#else
  uint8_t *p = ( uint8_t * )dst;
  p[0] = (uint8_t)(w >>  0);
  p[1] = (uint8_t)(w >>  8);
  p[2] = (uint8_t)(w >> 16);
  p[3] = (uint8_t)(w >> 24);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shrl $0x0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
// File: ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_init_key
int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = (uint8_t)keylen;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  P->node_depth    = 0;
  P->inner_length  = 0;
  memset( P->reserved, 0, sizeof( P->reserved ) );
  memset( P->salt,     0, sizeof( P->salt ) );
  memset( P->personal, 0, sizeof( P->personal ) );

  if( blake2b_init_param( S, P ) < 0 ) return -1;

  {
    uint8_t block[BLAKE2B_BLOCKBYTES];
    memset( block, 0, BLAKE2B_BLOCKBYTES );
    memcpy( block, key, keylen );
    blake2b_update( S, block, BLAKE2B_BLOCKBYTES );
    secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcad9
cmpq $0x40, -0x18(%rbp)
jbe 0xcae5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcbfc
cmpq $0x0, -0x20(%rbp)
je 0xcafa
cmpq $0x0, -0x28(%rbp)
je 0xcafa
cmpq $0x40, -0x28(%rbp)
jbe 0xcb06
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcbfc
movq -0x18(%rbp), %rax
movb %al, -0x70(%rbp)
movq -0x28(%rbp), %rax
movb %al, -0x6f(%rbp)
movb $0x1, -0x6e(%rbp)
movb $0x1, -0x6d(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x4, %rdi
xorl %esi, %esi
callq 0xca60
leaq -0x70(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0xca60
leaq -0x70(%rbp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
callq 0xca60
movb $0x0, -0x60(%rbp)
movb $0x0, -0x5f(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x12, %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0x41b0
leaq -0x70(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x41b0
leaq -0x70(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x41b0
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xc810
cmpl $0x0, %eax
jge 0xcba8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcbfc
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x41b0
leaq -0xf0(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x42a0
movq -0x10(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
movl $0x80, %edx
callq 0xcc10
leaq -0xf0(%rbp), %rdi
movl $0x80, %esi
callq 0xcd50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_update
int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )
{
  const unsigned char * in = (const unsigned char *)pin;
  if( inlen > 0 )
  {
    size_t left = S->buflen;
    size_t fill = BLAKE2B_BLOCKBYTES - left;
    if( inlen > fill )
    {
      S->buflen = 0;
      memcpy( S->buf + left, in, fill ); /* Fill buffer */
      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
      blake2b_compress( S, S->buf ); /* Compress */
      in += fill; inlen -= fill;
      while(inlen > BLAKE2B_BLOCKBYTES) {
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
        blake2b_compress( S, in );
        in += BLAKE2B_BLOCKBYTES;
        inlen -= BLAKE2B_BLOCKBYTES;
      }
    }
    memcpy( S->buf + S->buflen, in, inlen );
    S->buflen += inlen;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0xcd3e
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x80, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xcd08
movq -0x8(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x42a0
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0xcd80
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
callq 0xcdc0
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x80, -0x18(%rbp)
jbe 0xcd06
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0xcd80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcdc0
movq -0x20(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq $0x80, %rax
movq %rax, -0x18(%rbp)
jmp 0xccc3
jmp 0xcd08
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x8(%rbp), %rax
addq 0xe0(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x42a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0xe0(%rax), %rcx
movq %rcx, 0xe0(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_final
int blake2b_final( blake2b_state *S, void *out, size_t outlen )
{
  uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
  size_t i;

  if( out == NULL || outlen < S->outlen )
    return -1;

  if( blake2b_is_lastblock( S ) )
    return -1;

  blake2b_increment_counter( S, S->buflen );
  blake2b_set_lastblock( S );
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
  blake2b_compress( S, S->buf );

  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
    store64( buffer + sizeof( S->h[i] ) * i, S->h[i] );

  memcpy( out, buffer, S->outlen );
  secure_zero_memory(buffer, sizeof(buffer));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x41b0
cmpq $0x0, -0x18(%rbp)
je 0x129dc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xe8(%rcx), %rax
jae 0x129e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ac4
movq -0x10(%rbp), %rdi
callq 0x12ad0
cmpl $0x0, %eax
je 0x12a02
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ac4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rsi
callq 0xcd80
movq -0x10(%rbp), %rdi
callq 0x12af0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rax
addq 0xe0(%rax), %rdi
movq -0x10(%rbp), %rax
movl $0x80, %edx
subq 0xe0(%rax), %rdx
xorl %esi, %esi
callq 0x41b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0xcdc0
movq $0x0, -0x68(%rbp)
cmpq $0x8, -0x68(%rbp)
jae 0x12a97
leaq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12b30
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x12a62
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rdx
callq 0x42a0
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0xcd50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: ndsol[P]git-mine/./blake2-impl.h
// Function: store64(void*, unsigned long)
static BLAKE2_INLINE void store64( void *dst, uint64_t w )
{
#if defined(NATIVE_LITTLE_ENDIAN)
  memcpy(dst, &w, sizeof w);
#else
  uint8_t *p = ( uint8_t * )dst;
  p[0] = (uint8_t)(w >>  0);
  p[1] = (uint8_t)(w >>  8);
  p[2] = (uint8_t)(w >> 16);
  p[3] = (uint8_t)(w >> 24);
  p[4] = (uint8_t)(w >> 32);
  p[5] = (uint8_t)(w >> 40);
  p[6] = (uint8_t)(w >> 48);
  p[7] = (uint8_t)(w >> 56);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x0, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopl (%rax)
// File: ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b
int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )
{
  blake2b_state S[1];

  /* Verify parameters */
  if ( NULL == in && inlen > 0 ) return -1;

  if ( NULL == out ) return -1;

  if( NULL == key && keylen > 0 ) return -1;

  if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;

  if( keylen > BLAKE2B_KEYBYTES ) return -1;

  if( keylen > 0 )
  {
    if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
  }
  else
  {
    if( blake2b_init( S, outlen ) < 0 ) return -1;
  }

  blake2b_update( S, ( const uint8_t * )in, inlen );
  blake2b_final( S, out, outlen );
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x12c0e
cmpq $0x0, -0x28(%rbp)
jbe 0x12c0e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x12c22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x12c3d
cmpq $0x0, -0x38(%rbp)
jbe 0x12c3d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
cmpq $0x0, -0x18(%rbp)
je 0x12c4b
cmpq $0x40, -0x18(%rbp)
jbe 0x12c57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
cmpq $0x40, -0x38(%rbp)
jbe 0x12c67
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
cmpq $0x0, -0x38(%rbp)
jbe 0x12c96
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0xcab0
cmpl $0x0, %eax
jge 0x12c94
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
jmp 0x12cb6
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc990
cmpl $0x0, %eax
jge 0x12cb4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce5
jmp 0x12cb6
leaq -0x130(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xcc10
leaq -0x130(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x129a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ndsol[P]git-mine/hashapi.cpp
// Function: hexdump(char*, unsigned long, unsigned char*, unsigned long)
int hexdump(char* buf, size_t buflen, uint8_t* bytes, size_t byteslen) {
  char* p = buf;
  size_t len = buflen;
  for (size_t i = 0; len > 0 && i < byteslen; i++) {
    size_t r = snprintf(p, len, "%02x", bytes[i]);
    if (r < len) {
      p += r;
      len -= r;
    } else {
      fprintf(stderr, "overflow on byte %zu\n", i);
      return 1;
    }
  }
  if (len) {
    *p = 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x49(%rbp)
jbe 0x12dea
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x12df6
jmp 0x12e7d
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x5a1f(%rip), %rdx      # 0x18830
movb $0x0, %al
callq 0x4550
cltq
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x12e45
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x12e6a
movq 0xd18c(%rip), %rax      # 0x1ffd8
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
leaq 0x59db(%rip), %rsi      # 0x18835
movb $0x0, %al
callq 0x44c0
movl $0x1, -0x4(%rbp)
jmp 0x12e92
jmp 0x12e6c
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x12dd0
cmpq $0x0, -0x38(%rbp)
je 0x12e8b
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/demo1.cpp
// Function: main
int main()
{
    redisContext *conn = redisConnect("127.0.0.1", 6379);
    if (conn != NULL && conn->err) {
        printf("connection error: %s\n", conn->errstr);
        return 0;
    }

    redisReply *reply;
    reply = (redisReply*)redisCommand(conn, "SET %s %s", "foo", "bar");
    freeReplyObject(reply);

    reply =(redisReply*) redisCommand(conn, "GET %s", "foo");
    std::cout<< reply->str<<std::endl;
    reply = (redisReply*) redisCommand(conn, "lrange list1 0 %s","-1");
    cout<<reply->str<<endl;
    freeReplyObject(reply);
    redisFree(conn);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x1377e(%rip), %rdi     # 0x17004
movl $0x18eb, %esi           # imm = 0x18EB
callq 0xfe40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38c6
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38c6
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
leaq 0x1375b(%rip), %rdi     # 0x1700e
movb $0x0, %al
callq 0x3070
movl $0x0, -0x4(%rbp)
jmp 0x398c
movq -0x10(%rbp), %rdi
leaq 0x13753(%rip), %rsi     # 0x17024
leaq 0x13756(%rip), %rdx     # 0x1702e
leaq 0x13753(%rip), %rcx     # 0x17032
movb $0x0, %al
callq 0x10940
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe290
movq -0x10(%rbp), %rdi
leaq 0x13738(%rip), %rsi     # 0x17036
leaq 0x13729(%rip), %rdx     # 0x1702e
movb $0x0, %al
callq 0x10940
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0x1a6b9(%rip), %rdi     # 0x1dfd8
callq 0x3380
movq %rax, %rdi
movq 0x1a69a(%rip), %rsi     # 0x1dfc8
callq 0x33b0
movq -0x10(%rbp), %rdi
leaq 0x136ff(%rip), %rsi     # 0x1703d
leaq 0x1370a(%rip), %rdx     # 0x1704f
movb $0x0, %al
callq 0x10940
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0x1a679(%rip), %rdi     # 0x1dfd8
callq 0x3380
movq %rax, %rdi
movq 0x1a65a(%rip), %rsi     # 0x1dfc8
callq 0x33b0
movq -0x18(%rbp), %rdi
callq 0xe290
movq -0x10(%rbp), %rdi
callq 0xfb80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Diggie-Bro[P]StreamCode/test/../misc/../src/builtin/io.h
// Function: getIOModule()
struct Module getIOModule() {
    struct Module ioModule;
    ioModule.module_names_ = "io";
    ioModule.configure_file_ = "io/config.strmcode";

    vector<string> module_vector;
    module_vector.push_back("io/cio.h");
    ioModule.module_files_ = module_vector;
    
    return ioModule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x2eb0
movq -0x68(%rbp), %rdi
leaq 0x6b26(%rip), %rsi      # 0x9004
callq 0x2250
jmp 0x24e5
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
leaq 0x6b13(%rip), %rsi      # 0x9007
callq 0x2250
jmp 0x24fb
leaq -0x38(%rbp), %rdi
callq 0x2ef0
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2300
movq -0x78(%rbp), %rdx
leaq 0x6afe(%rip), %rsi      # 0x901a
leaq -0x58(%rbp), %rdi
callq 0x2260
jmp 0x2527
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2f10
jmp 0x2536
leaq -0x58(%rbp), %rdi
callq 0x2120
leaq -0x59(%rbp), %rdi
callq 0x21f0
movq -0x68(%rbp), %rdi
addq $0x40, %rdi
leaq -0x38(%rbp), %rsi
callq 0x2f40
jmp 0x255b
movb $0x1, -0x9(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3190
testb $0x1, -0x9(%rbp)
jne 0x25cc
jmp 0x25c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x25d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x25a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2120
leaq -0x59(%rbp), %rdi
callq 0x21f0
jmp 0x25b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3190
jmp 0x25d9
movq -0x68(%rbp), %rdi
callq 0x31f0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x31f0
movq -0x18(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: Diggie-Bro[P]StreamCode/test/../misc/../src/builtin/io.h
// Function: executor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Variables, std::allocator<Variables>>)
struct Variables executor(string function, vector<struct Variables> param) {
    if (function == "print") {
        cio_std_out(param.at(0));
        struct Variables return_variable;
        return_variable.type = VOID;
        return_variable.value = "";
        return return_variable;
    } else {
        struct Variables return_variable;
        return_variable.type = VOID;
        return_variable.value = "";
        return return_variable;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x69fb(%rip), %rsi      # 0x9023
callq 0x3230
testb $0x1, %al
jne 0x2636
jmp 0x26d8
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3260
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x32a0
movq -0x78(%rbp), %rdi
callq 0x2480
jmp 0x265e
leaq -0x40(%rbp), %rdi
callq 0x32e0
movq -0x60(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
callq 0x3300
movq -0x60(%rbp), %rdi
movl $0x4, (%rdi)
addq $0x8, %rdi
leaq 0x6a9b(%rip), %rsi      # 0x9124
callq 0x2250
jmp 0x2690
movb $0x1, -0x4d(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x26d6
jmp 0x26cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x32e0
jmp 0x273c
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x32e0
jmp 0x273c
movq -0x60(%rbp), %rdi
callq 0x32e0
jmp 0x272f
movq -0x60(%rbp), %rdi
movb $0x0, -0x4e(%rbp)
callq 0x3300
movq -0x60(%rbp), %rdi
movl $0x4, (%rdi)
addq $0x8, %rdi
leaq 0x6a2a(%rip), %rsi      # 0x9124
callq 0x2250
jmp 0x2701
movb $0x1, -0x4e(%rbp)
testb $0x1, -0x4e(%rbp)
jne 0x272d
jmp 0x2724
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x32e0
jmp 0x273c
movq -0x60(%rbp), %rdi
callq 0x32e0
jmp 0x272f
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: Diggie-Bro[P]StreamCode/test/../misc/../src/runtime/memory.h
// Function: VariableManager::editVariable(VariableMem*, Variables&)
void editVariable(struct VariableMem* mem, struct Variables& variable) {
            if (variable.type != mem->type) return;
            if (mem->type == INT) {
                int nvariable = mem->integerMem;
                nvariable = atoi(variable.value.c_str());
            } else if (mem->type == DOUBLE) {
                double nvariable = mem->doubleMem;
                nvariable = atof(variable.value.c_str());
            } else if (mem->type == STRING) {
                string nvariable = mem->stringMem;
            } else if (mem->type == BOOL) {
                bool nvariable = mem->booleanMem;
                nvariable = variable.value == "false" ? false : true;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4307
jmp 0x43c5
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4337
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20b0
movq %rax, %rdi
callq 0x22c0
movl %eax, -0x1c(%rbp)
jmp 0x43c5
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x436a
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20b0
movq %rax, %rdi
callq 0x2230
movsd %xmm0, -0x28(%rbp)
jmp 0x43c3
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x438f
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
leaq -0x48(%rbp), %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0x43c1
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x43bf
movq -0x10(%rbp), %rax
movb 0x58(%rax), %al
andb $0x1, %al
movb %al, -0x49(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4c9b(%rip), %rsi      # 0x904e
callq 0x3230
decb %al
andb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x43c1
jmp 0x43c3
jmp 0x43c5
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Diggie-Bro[P]StreamCode/test/../misc/../src/runtime/memory.h
// Function: VariableManager::getVariable(VariableMem*)
struct Variables getVariable(struct VariableMem* mem) {
            struct Variables variable {mem->type, ""};
            if (mem->type == INT) variable.value = to_string(mem->integerMem);
            else if (mem->type == DOUBLE) variable.value = to_string(mem->doubleMem);
            else if (mem->type == STRING) variable.value = mem->stringMem;
            else if (mem->type == BOOL) variable.value = (mem->booleanMem == true ? "true" : "false");
            return variable;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2300
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x4acc(%rip), %rsi      # 0x9124
callq 0x2260
jmp 0x465f
leaq -0x1a(%rbp), %rdi
callq 0x21f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x46dc
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x5de0
jmp 0x4683
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
callq 0x2210
leaq -0x50(%rbp), %rdi
callq 0x2120
jmp 0x477c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x21f0
jmp 0x47a2
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x32e0
jmp 0x47a2
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4718
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
leaq -0x70(%rbp), %rdi
callq 0x5f00
jmp 0x46f9
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
callq 0x2210
leaq -0x70(%rbp), %rdi
callq 0x2120
jmp 0x477a
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x473d
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rsi
addq $0x8, %rdi
callq 0x2030
jmp 0x473b
jmp 0x4778
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x4776
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x58(%rax), %cl
leaq 0x491d(%rip), %rax      # 0x9078
leaq 0x48ec(%rip), %rsi      # 0x904e
testb $0x1, %cl
cmovneq %rax, %rsi
addq $0x8, %rdi
callq 0x2250
jmp 0x4774
jmp 0x4776
jmp 0x4778
jmp 0x477a
jmp 0x477c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4792
movq -0x90(%rbp), %rdi
callq 0x32e0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: onlyuser[P]Sandbox/test_c/pre_0x/main3.cpp
// Function: main
int main(int argc, char** argv)
{
    int x = 0;

    // function declaration!! -- because "int(x)" is interpreted as "int x"
    // NOTE: "int(x)" is not a typecast
    int y(int(x));
    std::cout << typeid(y).name() << std::endl; // int (int)

    // variable initialization -- because "g" is not a type
    int f(g(x));
    std::cout << typeid(f).name() << std::endl; // int

    // function declaration!! -- because "g2" is a type
    // NOTE: "g2()" is not a default constructor call
    g2 f2(g2());
    std::cout << typeid(f2).name() << std::endl; // g2 (g2 (*)())

    // function declaration!! -- because "g3" is a type
    int f3(g3(x));
    std::cout << typeid(f3).name() << std::endl; // int (int (*)(int))

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x2b94(%rip), %rdi      # 0x3d78
callq 0x12a0
movq %rax, %rsi
movq 0x2de5(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
movq 0x2dc6(%rip), %rsi      # 0x3fc8
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x11b0
movl %eax, -0x18(%rbp)
movq 0x2d9f(%rip), %rdi      # 0x3fb8
callq 0x12a0
movq %rax, %rsi
movq 0x2db0(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
movq 0x2d91(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq 0x2b45(%rip), %rdi      # 0x3d88
callq 0x12a0
movq %rax, %rsi
movq 0x2d86(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
movq 0x2d67(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq 0x2b2b(%rip), %rdi      # 0x3d98
callq 0x12a0
movq %rax, %rsi
movq 0x2d5c(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
movq 0x2d3d(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void print_array<unsigned int, unsigned long>(unsigned int*, unsigned long)
void print_array(T *a, I n) {
    if (n < 50) {
        for (I i = 0; i < n-1; i++) {
            std::cout << a[i] << ",";
        }
        std::cout << a[n-1] << std::endl;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x32, 0x8(%rsp)
jae 0x23d1
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x23a5
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x6c4d(%rip), %rdi      # 0x8fd0
callq 0x10e0
movq %rax, %rdi
leaq 0x3e1c(%rip), %rsi      # 0x61ae
callq 0x10a0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x235e
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %esi
movq 0x6c13(%rip), %rdi      # 0x8fd0
callq 0x10e0
movq %rax, %rdi
movq 0x6bf4(%rip), %rsi      # 0x8fc0
callq 0x10b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void jain_inshuffle<unsigned int, unsigned long>(unsigned int*, unsigned long)
void jain_inshuffle(Data *a, Index n) {
	while (n > 1) {
		// Compute appropriate value of m
		Index m = 1;
		while (3*m-1 <= n) m *= 3;
		m -= 1;

		// Move correct m elements to front of the array
		std::rotate(a+m/2, a+n/2, a+n/2+m/2);

		// Now use Jain's trick to shuffle a[0,...,m-1];
		for (Index g = 1; g < m; g *= 3) {
			Index cur = g-1;
			Data t = a[cur];
			do {
				Index nxt = inshuffle_perm3(cur, m);
				Data t2 = a[nxt];
				a[nxt] = t;
				t = t2;
				cur = nxt;
			} while (cur != g-1);
		}

		// Recurse on a[m,...n-1]
		a += m;
		n -= m;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x1, 0x38(%rsp)
jbe 0x254e
movq $0x1, 0x30(%rsp)
imulq $0x3, 0x30(%rsp), %rax
subq $0x1, %rax
cmpq 0x38(%rsp), %rax
ja 0x2421
imulq $0x3, 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2403
movq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x2524
movq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3670
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %edx
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x24b7
jmp 0x2514
imulq $0x3, 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x2488
movq 0x30(%rsp), %rax
shlq $0x2, %rax
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x38(%rsp)
jmp 0x23ee
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void check_inshuffle_output<unsigned int, unsigned long>(unsigned int*, unsigned long)
void check_inshuffle_output(Data *a, Index n) {
	for (Index i = 0; i < n; i++) {
		if (a[i] != outshuffle_perm3(i, n)) {
			std::cerr << "Mistake in output!!!" << std::endl;
			exit(-1);
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x268f
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3e50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x267d
movq 0x6998(%rip), %rdi      # 0x8ff0
leaq 0x3b51(%rip), %rsi      # 0x61b0
callq 0x10a0
movq %rax, %rdi
movq 0x6952(%rip), %rsi      # 0x8fc0
callq 0x10b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10d0
jmp 0x267f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2617
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: patmorin[P]rotate/jain.cpp
// Function: void prime_inshuffle<unsigned int, unsigned long>(unsigned int*, unsigned long)
void prime_inshuffle(Data *a, Index n) {
	while (n > 1) {
		// Compute appropriate value of m
		int i = 0;
		while (sprimes[i+1] <= n) i++;
		Index m = sprimes[i];

		// Move correct m elements to front of the array
		std::rotate(a+m/2, a+n/2, a+n/2+m/2);

		// Now use Jain's trick to shuffle a[0,...,m-1];
		Index cur = 0;
		Data t = a[cur];
		do {
			Index nxt = inshuffle_perm3(cur, m);
			Data t2 = a[nxt];
			a[nxt] = t;
			t = t2;
			cur = nxt;
		} while (cur != 0);

		// Recurse on a[m,...n-1]
		a += m;
		n -= m;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x1, 0x38(%rsp)
jbe 0x27e4
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x69fd(%rip), %rax      # 0x90d0
movq (%rax,%rcx,8), %rax
cmpq 0x38(%rsp), %rax
ja 0x26eb
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x26c2
movslq 0x34(%rsp), %rcx
leaq 0x69d9(%rip), %rax      # 0x90d0
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x28(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3670
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %edx
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x276a
movq 0x28(%rsp), %rax
shlq $0x2, %rax
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x38(%rsp)
jmp 0x26ae
addq $0x48, %rsp
retq
nopl (%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void prime_outshuffle<unsigned int, unsigned long>(unsigned int*, unsigned long)
void prime_outshuffle(Data *a, Index n) {
	if (n <= 1) return;

	// Compute appropriate value of m
	int i = 0;
	while (sprimes[i+1] <= n) i++;
	Index m = sprimes[i];

	// Follow the cycle through a[0,...,m-1];
	Index cur = 0;
	Data t[2];
	int flipflop = 0;
	t[flipflop] = a[cur];
	do {
		Index nxt = outshuffle_perm3(cur, m);
		t[!flipflop] = a[nxt];
		a[nxt] = t[flipflop];
		flipflop = !flipflop;
		cur = nxt;
	} while (cur != 0);

	// Recurse on a[m,...n-1]
	prime_outshuffle(a+m, n-m);

	// Regroup odds and evens
	std::rotate(a+m/2, a+m, a+m+(n-m)/2);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x1, 0x38(%rsp)
ja 0x2deb
jmp 0x2f36
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x62cc(%rip), %rax      # 0x90d0
movq (%rax,%rcx,8), %rax
cmpq 0x38(%rsp), %rax
ja 0x2e1c
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2df3
movslq 0x34(%rsp), %rcx
leaq 0x62a8(%rip), %rax      # 0x90d0
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movslq 0x14(%rsp), %rax
movl %ecx, 0x18(%rsp,%rax,4)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3e50
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %ecx, 0x18(%rsp,%rax,4)
movslq 0x14(%rsp), %rax
movl 0x18(%rsp,%rax,4), %edx
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2e58
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
subq 0x28(%rsp), %rsi
callq 0x2dd0
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x40(%rsp), %rdx
movq 0x28(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x38(%rsp), %rax
subq 0x28(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void check_outshuffle_output<unsigned int, unsigned long>(unsigned int*, unsigned long)
void check_outshuffle_output(Data *a, Index n) {
	for (Index i = 0; i < n; i++) {
		if (a[i] != inshuffle_perm3(i, n)) {
			std::cerr << "Mistake in output!!!" << std::endl;
			exit(-1);
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2fcf
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3670
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x2fbd
movq 0x6058(%rip), %rdi      # 0x8ff0
leaq 0x3211(%rip), %rsi      # 0x61b0
callq 0x10a0
movq %rax, %rdi
movq 0x6012(%rip), %rsi      # 0x8fc0
callq 0x10b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10d0
jmp 0x2fbf
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f57
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: patmorin[P]rotate/jain.cpp
// Function: void blocked_outshuffle<96u, false, unsigned int, unsigned long>(unsigned int*, unsigned long)
void blocked_outshuffle(Data *a, Index n) {
	Index r = n % (2*B);
	Index m = n - r;

	prime_outshuffle(a+m, r);

	for(Index i = 0; i < m/(2*B); i++) {
		static_assert(B==96, "Assuming B==96");
		//rev_outshuffle128(a+(2*B)*i);
		rev_outshuffle192(a+(2*B)*i);
		//rev_outshuffle<2*B>(a+(2*B)*i);
	}
	struct block { Data dummy[B];	};
	if (prefetch) {
		prime_outshuffle_pf<4>((block*)a, m/B);
	} else {
		prime_outshuffle((block*)a, m/B);
	}

	// Regroup odds and evens
	std::rotate(a+m/2, a+m, a+m+r/2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl $0xc0, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x2dd0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl $0xc0, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3085
movq 0x30(%rsp), %rdi
imulq $0xc0, 0x10(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3eb0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3035
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
callq 0x3f80
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x20(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
addq $0x38, %rsp
retq
// File: patmorin[P]rotate/jain.cpp
// Function: void jain_outshuffle<unsigned int, unsigned long>(unsigned int*, unsigned long)
void jain_outshuffle(Data *a, Index n) {
	if (n <= 1) return;
	// Compute appropriate value of m
	Index m = 1;
	while (3*m-1 <= n) m *= 3;
	m -= 1;

	// Use Jain's trick to shuffle a[0,...,m-1];
	for (Index g = 1; g < m; g *= 3) {
		Index cur = g-1;
		Data t[2];
		int flipflop = 0;
		t[flipflop] = a[cur];
		do {
			Index nxt = outshuffle_perm3(cur, m);
			t[!flipflop] = a[nxt];
			a[nxt] = t[flipflop];
			flipflop = !flipflop;
			cur = nxt;
		} while (cur != g-1);
	}

	// Recurse on a[m,...n-1]
	jain_outshuffle(a+m, n-m);

	// Regroup odds and evens
	std::rotate(a+m/2, a+m, a+m+(n-m)/2);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x1, 0x38(%rsp)
ja 0x321b
jmp 0x3390
movq $0x1, 0x30(%rsp)
imulq $0x3, 0x30(%rsp), %rax
subq $0x1, %rax
cmpq 0x38(%rsp), %rax
ja 0x3242
imulq $0x3, 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3224
movq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x3321
movq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movslq 0x14(%rsp), %rax
movl %ecx, 0x18(%rsp,%rax,4)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3e50
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %ecx, 0x18(%rsp,%rax,4)
movslq 0x14(%rsp), %rax
movl 0x18(%rsp,%rax,4), %edx
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x3295
jmp 0x3311
imulq $0x3, 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x3259
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
subq 0x30(%rsp), %rsi
callq 0x3200
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x38(%rsp), %rax
subq 0x30(%rsp), %rax
shrq %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: patmorin[P]rotate/jain.cpp
// Function: void blocked_eytzinger<96u, true, unsigned int, unsigned long>(unsigned int*, unsigned long)
void blocked_eytzinger(Data *a, Index n) {
	Index h = 0;
	Index m = 0;
	while (m + (1<<h) < n) {
		m += 1<<h;
		h++;
	}
	Index r = n - m;
	blocked_outshuffle<B,prefetch>(a, 2*r);
	std::rotate(a+r, a+2*r, a+n);
	Index one = 1;
	while (h > 0) {
		blocked_outshuffle<B,prefetch>(a, (one<<h)-1);
		h--;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
cmpq 0x28(%rsp), %rax
jae 0x340a
movq 0x20(%rsp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x33c0
movq 0x28(%rsp), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq %rsi
callq 0x30f0
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3610
movq $0x1, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0x34a2
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
shlq %cl, %rsi
subq $0x1, %rsi
callq 0x30f0
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x346f
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: patmorin[P]rotate/jain.cpp
// Function: void rev_outshuffle192<unsigned int>(unsigned int*)
void rev_outshuffle192(Data *a) {
	const static int A = 2, B = 95;
	const static std::uint32_t cycles[A][B] = {
		{1, 96, 48, 24, 12, 6, 3, 97, 144, 72, 36, 18, 9, 100, 50, 25, 108, 54, 27, 109, 150, 75, 133, 162, 81, 136, 68, 34, 17, 104, 52, 26, 13, 102, 51, 121, 156, 78, 39, 115, 153, 172, 86, 43, 117, 154, 77, 134, 67, 129, 160, 80, 40, 20, 10, 5, 98, 49, 120, 60, 30, 15, 103, 147, 169, 180, 90, 45, 118, 59, 125, 158, 79, 135, 163, 177, 184, 92, 46, 23, 107, 149, 170, 85, 138, 69, 130, 65, 128, 64, 32, 16, 8, 4, 2},
		{7, 99, 145, 168, 84, 42, 21, 106, 53, 122, 61, 126, 63, 127, 159, 175, 183, 187, 189, 190, 95, 143, 167, 179, 185, 188, 94, 47, 119, 155, 173, 182, 91, 141, 166, 83, 137, 164, 82, 41, 116, 58, 29, 110, 55, 123, 157, 174, 87, 139, 165, 178, 89, 140, 70, 35, 113, 152, 76, 38, 19, 105, 148, 74, 37, 114, 57, 124, 62, 31, 111, 151, 171, 181, 186, 93, 142, 71, 131, 161, 176, 88, 44, 22, 11, 101, 146, 73, 132, 66, 33, 112, 56, 28, 14}
	};
	for (int i = 0; i < A; i++) {
		Data t1 = a[cycles[i][B-1]];
		for (int j = 0; j < B; j++) {
			Data t2 = a[cycles[i][j]];
			a[cycles[i][j]] = t1;
			t1 = t2;
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x2, -0xc(%rsp)
jge 0x3f7a
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rdx
leaq 0x22f7(%rip), %rcx      # 0x61d0
imulq $0x17c, %rdx, %rdx      # imm = 0x17C
addq %rdx, %rcx
movl 0x178(%rcx), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x5f, -0x14(%rsp)
jge 0x3f68
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rdx
leaq 0x22c0(%rip), %rcx      # 0x61d0
imulq $0x17c, %rdx, %rdx      # imm = 0x17C
addq %rdx, %rcx
movslq -0x14(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
movl -0x10(%rsp), %edx
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rsi
leaq 0x2292(%rip), %rcx      # 0x61d0
imulq $0x17c, %rsi, %rsi      # imm = 0x17C
addq %rsi, %rcx
movslq -0x14(%rsp), %rsi
movl (%rcx,%rsi,4), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3ef8
jmp 0x3f6a
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3ebd
retq
nopl (%rax,%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: init_c()
void init_c() {
    for(int i=0;i<8;i++) {
        if(i==0) {
            cu[i] = sqrt(1.0/8.0);
            cv[i] = sqrt(1.0/8.0);
        } else {
            cu[i] = sqrt(2.0/8.0);
            cv[i] = sqrt(2.0/8.0);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x2615
cmpl $0x0, -0x4(%rbp)
jne 0x25cb
movsd 0x5a79(%rip), %xmm0     # 0x8010
callq 0x2100
movslq -0x4(%rbp), %rcx
leaq 0x8be9(%rip), %rax      # 0xb190
movsd %xmm0, (%rax,%rcx,8)
movsd 0x5a5c(%rip), %xmm0     # 0x8010
callq 0x2100
movslq -0x4(%rbp), %rcx
leaq 0x8c0c(%rip), %rax      # 0xb1d0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2605
movsd 0x5a35(%rip), %xmm0     # 0x8008
callq 0x2100
movslq -0x4(%rbp), %rcx
leaq 0x8bad(%rip), %rax      # 0xb190
movsd %xmm0, (%rax,%rcx,8)
movsd 0x5a18(%rip), %xmm0     # 0x8008
callq 0x2100
movslq -0x4(%rbp), %rcx
leaq 0x8bd0(%rip), %rax      # 0xb1d0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2607
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x257f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: readCOM(unsigned char*&)
void readCOM(byte *&jpegdata) {
    std::cout<<"\n************COM INFO*******************\n";
    int length = readSectionLength(jpegdata);
    std::cout<<"本数据段的长度为："<<length<<"\n";
    byte *comdata = new byte[length-2];  //length 包括前面的长度信息数据所占的2个字节
    memcpy(comdata, jpegdata, length-2);
    jpegdata = jpegdata + (length-2);

    for(int i=0; i<length-2; i++) {
        std::cout<<comdata[i];
    }
    std::cout<<"\n";
    if(comdata != nullptr) {
        delete[] comdata;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x852d(%rip), %rdi      # 0xafd0
leaq 0x5a12(%rip), %rsi      # 0x84bc
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x3d40
movl %eax, -0xc(%rbp)
movq 0x850e(%rip), %rdi      # 0xafd0
leaq 0x5723(%rip), %rsi      # 0x81ec
callq 0x2130
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x5ec7(%rip), %rsi      # 0x89aa
callq 0x2130
movl -0xc(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rdx
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl -0xc(%rbp), %eax
subl $0x2, %eax
cltq
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x2b63
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x8481(%rip), %rdi      # 0xafd0
movzbl (%rax,%rcx), %esi
callq 0x2200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b33
movq 0x8466(%rip), %rdi      # 0xafd0
leaq 0x5e39(%rip), %rsi      # 0x89aa
callq 0x2130
cmpq $0x0, -0x18(%rbp)
je 0x2b96
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2b94
movq -0x28(%rbp), %rdi
callq 0x21a0
jmp 0x2b96
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: readSectionLength(unsigned char*&)
int readSectionLength(byte *&jpegdata) {
    byte tmp;
    int length = 0;
    memcpy(&tmp, jpegdata++, 1);
    length = tmp;
    memcpy(&tmp, jpegdata++, 1);
    length = length*256 + tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
shll $0x8, %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
ud2
nopw %cs:(%rax,%rax)