LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_stream_status
static void send_stream_status(stream_t *p_stream)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE];
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_STREAM_STATUS);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE);

    ecmg_append_channelid(p_tlv, i_channelid);
    ecmg_append_streamid(p_tlv, p_stream->i_streamid);
    if (i_version >= 2)
        ecmg_append_ecmid(p_tlv, p_stream->i_ecmid);
    ecmg_append_accesscritmode(p_tlv, true);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x1770
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
movzbl 0x4839(%rip), %esi      # 0x8079
callq 0x2490
movq -0x418(%rbp), %rdi
callq 0x24b0
movq -0x418(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x24d0
movq -0x418(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x418(%rbp), %rdi
movzwl 0x4807(%rip), %esi      # 0x8088
callq 0x2550
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
callq 0x3930
movzbl 0x47d9(%rip), %eax      # 0x8079
cmpl $0x2, %eax
jl 0x38b9
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %esi
callq 0x3a00
movq -0x418(%rbp), %rdi
movl $0x1, %esi
callq 0x3ad0
movq -0x418(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x420(%rbp)
movq -0x418(%rbp), %rdi
movq -0x420(%rbp), %rax
movq -0x418(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x410(%rbp), %rdi
movq -0x420(%rbp), %rsi
leaq -0x410(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_stream_close
static void send_stream_close(stream_t *p_stream)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE];
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_STREAM_CLOSERESP);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE);

    ecmg_append_channelid(p_tlv, i_channelid);
    ecmg_append_streamid(p_tlv, p_stream->i_streamid);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x1770
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
movzbl 0x44a9(%rip), %esi      # 0x8079
callq 0x2490
movq -0x418(%rbp), %rdi
callq 0x24b0
movq -0x418(%rbp), %rdi
movl $0x105, %esi            # imm = 0x105
callq 0x24d0
movq -0x418(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x418(%rbp), %rdi
movzwl 0x4477(%rip), %esi      # 0x8088
callq 0x2550
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
callq 0x3930
movq -0x418(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x420(%rbp)
movq -0x418(%rbp), %rdi
movq -0x420(%rbp), %rax
movq -0x418(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x410(%rbp), %rdi
movq -0x420(%rbp), %rsi
leaq -0x410(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: build_ecm
static void build_ecm(stream_t *p_stream, uint16_t i_cp_number,
                      uint8_t * const ppi_cw[2],
                      uint8_t *p_accesscrit_param)
{
    /* you will want to customize this function */
    static const uint8_t pi_xor[8] =
        {0x42, 0x12, 0x02, 0x24, 0x21, 0x20, 0x66, 0x88};
    PSI_DECLARE(p_section);
    uint8_t *pi_ecm;
    int i, j;

    psi_init(p_section, false);
    psi_set_tableid(p_section, 0x80 | (i_cp_number & 0x1));
    psi_set_length(p_section, 16);

    pi_ecm = p_section + 3;
    for (i = 0; i < 2; i++)
        for (j = 0; j < 8; j++)
            pi_ecm[i * 8 + j] = ppi_cw[i][j] ^ pi_xor[j];

    send_ecm(p_stream, i_cp_number, p_section,
             psi_get_length(p_section) + PSI_HEADER_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
callq 0x3f30
leaq -0x420(%rbp), %rdi
movzwl -0xa(%rbp), %eax
andl $0x1, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x3f70
leaq -0x420(%rbp), %rdi
movl $0x10, %esi
callq 0x3f90
leaq -0x420(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x428(%rbp)
movl $0x0, -0x42c(%rbp)
cmpl $0x2, -0x42c(%rbp)
jge 0x3ec7
movl $0x0, -0x430(%rbp)
cmpl $0x8, -0x430(%rbp)
jge 0x3eb1
movq -0x18(%rbp), %rax
movslq -0x42c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x430(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x430(%rbp), %rdx
leaq 0x1568(%rip), %rcx      # 0x53e4
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x428(%rbp), %rax
movl -0x42c(%rbp), %ecx
shll $0x3, %ecx
addl -0x430(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x430(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x430(%rbp)
jmp 0x3e4b
jmp 0x3eb3
movl -0x42c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x42c(%rbp)
jmp 0x3e34
movq -0x8(%rbp), %rax
movq %rax, -0x448(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x43a(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x4100
movq -0x448(%rbp), %rdi
movw -0x43a(%rbp), %cx
movq -0x438(%rbp), %rdx
movzwl %ax, %eax
addl $0x3, %eax
movzwl %cx, %esi
movzwl %ax, %ecx
callq 0x3fe0
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_ecm
static void send_ecm(stream_t *p_stream, uint16_t i_cp_number,
                     const uint8_t *p_ecm, uint16_t i_length)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE + i_length]; /* this is oversized */
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_ECM);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE
                           + i_length);

    ecmg_append_channelid(p_tlv, i_channelid);
    ecmg_append_streamid(p_tlv, p_stream->i_streamid);
    ecmg_append_cpnumber(p_tlv, i_cp_number);
    tlv_append_data(p_tlv, ECMG_PARAM_ECM, p_ecm, i_length);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %cx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %ecx
movl %ecx, %eax
addl $0x3fc, %eax            # imm = 0x3FC
movq %rsp, %rdx
movq %rdx, -0x28(%rbp)
addl $0x40b, %ecx            # imm = 0x40B
andl $-0x10, %ecx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
callq 0x1770
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movzbl 0x403b(%rip), %esi      # 0x8079
callq 0x2490
movq -0x38(%rbp), %rdi
callq 0x24b0
movq -0x38(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x24d0
movq -0x38(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
addl $0x3f7, %eax            # imm = 0x3F7
movzwl %ax, %esi
callq 0x2510
movq -0x38(%rbp), %rdi
movzwl 0x400e(%rip), %esi      # 0x8088
callq 0x2550
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
callq 0x3930
movq -0x38(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x4150
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x15, %esi
movzwl -0x1a(%rbp), %ecx
callq 0x4220
movq -0x38(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x12a0
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: tlv_append_data
static inline bool tlv_append_data(uint8_t *p_tlv, uint16_t i_type,
                                   const uint8_t *p_data, uint16_t i_length)
{
    uint8_t *p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    if (!tlv_validate_param(p_tlv, p_tlv_n,
                            i_length + TLV_PARAM_EMPTY_SIZE))
        return false;
    tlv_set_type(p_tlv_n, i_type);
    tlv_set_length(p_tlv_n, i_length);
    memcpy(p_tlv_n + 4, p_data, i_length);
    tlv_append_empty(p_tlv_n);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movzwl -0x22(%rbp), %eax
addl $0x2, %eax
movzwl %ax, %edx
callq 0x26d0
testb $0x1, %al
jne 0x4270
movb $0x0, -0x1(%rbp)
jmp 0x42ae
movq -0x30(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x24d0
movq -0x30(%rbp), %rdi
movzwl -0x22(%rbp), %esi
callq 0x2510
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rsi
movzwl -0x22(%rbp), %eax
movl %eax, %edx
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x2720
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal.c
// Function: help
void help(){
  printf("Usage:\n");
  printf("./feistal -i <infile_name> -o <outfile_name> -<op>\n\
      -i      input file name\n\
      -o      output file name\noption (op): \n\
      -e      encrypt given file\n\
      -d      decrypt given file\n\n");
  printf("Note: Use ./feistal -g to generate 64 bits keys. ");
  printf("Keys should be 64 bits i.e. 8 characters.\n\n");
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xdd9(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
leaq 0xdd3(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1070
leaq 0xe87(%rip), %rdi       # 0x20ce
movb $0x0, %al
callq 0x1070
leaq 0xeab(%rip), %rdi       # 0x2100
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal.c
// Function: fesital
void fesital(FILE *ifile, FILE *ofile, int op)
{
  uint32_t keys[ROUNDS] = { 0xDEAD, 0xBEEF, 0xBAAD, 0xF00D, 0xFEED, 0xFACE, 0xCAFE, 0xBABE, 0xDEAD, 0xBABE, 0xD15, 0xEA5E, 0xDECE, 0xA5ED, 0xBAAD, 0xAC1D };
  char *key = getKey();
  if(!generateSubKeys(key, keys)){
    help();
    printf("Error: key generation getting failed\n");
    return;
  }
  switch(op){
    case 0:
      encrypt_ecb(ifile, ofile, keys);
      printf("Encrypted file is generated\n");
      break;
    case 1:
      decrypt_ecb(ifile, ofile, keys);
      printf("Decrypted file is generated\n");
      break;
    default:
      printf("Invalid option\n");
      break;
  }
  free(key);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0xf32(%rip), %rsi       # 0x21b0
movl $0x40, %edx
callq 0x10b0
callq 0x1330
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1610
cmpl $0x0, %eax
jne 0x12b8
callq 0x1220
leaq 0xe7d(%rip), %rdi       # 0x212c
movb $0x0, %al
callq 0x1070
jmp 0x1327
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
testl %eax, %eax
je 0x12ce
jmp 0x12c4
movl -0x6c(%rbp), %eax
subl $0x1, %eax
je 0x12ef
jmp 0x1310
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x13b0
leaq 0xe6c(%rip), %rdi       # 0x2152
movb $0x0, %al
callq 0x1070
jmp 0x131e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x14e0
leaq 0xe68(%rip), %rdi       # 0x216f
movb $0x0, %al
callq 0x1070
jmp 0x131e
leaq 0xe75(%rip), %rdi       # 0x218c
movb $0x0, %al
callq 0x1070
movq -0x68(%rbp), %rdi
callq 0x1030
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal.c
// Function: getKey
static char *getKey(){
  char *p = (char *)malloc(sizeof(char)*10);
  size_t size = sizeof(char)*10;
  memset(p,'\0',sizeof(char)*10);
  printf("Enter key: ");
  getline(&p, &size, stdin);
  if(strlen(p)!=9){
    return NULL;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xa, %edi
callq 0x10d0
movq %rax, -0x10(%rbp)
movq $0xa, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1080
leaq 0xe37(%rip), %rdi       # 0x219c
movb $0x0, %al
callq 0x1070
movq 0x2c6d(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x1060
cmpq $0x9, %rax
je 0x139c
movq $0x0, -0x8(%rbp)
jmp 0x13a4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_encrypt.c
// Function: encrypt_ecb
void encrypt_ecb(FILE *infile, FILE *outfile, uint32_t keys[])
{
  uint32_t left, right;
  size_t ret;
  uint64_t sblock;
  memset(&sblock,0,sizeof(sblock));
  while(fread(&sblock, sizeof(sblock), 1, infile)){    
    left = (sblock>>32);
    right = ((sblock<<32)>>32);
    sblock = encrypt(left, right, keys);
    fwrite(&sblock,1,sizeof(sblock), outfile);
    memset(&sblock,0,sizeof(sblock));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1080
movq -0x8(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x1040
cmpq $0x0, %rax
je 0x1447
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
shlq $0x20, %rax
shrq $0x20, %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1450
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x1100
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1080
jmp 0x13d4
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_encrypt.c
// Function: encrypt
static uint64_t encrypt(uint32_t left, uint32_t right, uint32_t keys[])
{
  uint32_t i, l1, r1;
  for(i=0; i<ROUNDS; i++) {
    r1 = left ^ xor_fun(right, keys[i]);
    l1 = right;
    if(i == (ROUNDS -1)) {
      left = r1;
      right = l1;
    } else {
      left = l1;
      right = r1;
    }
  }
  return (uint64_t)left<<32 | right;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jae 0x14c4
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x1700
movl %eax, %ecx
movl -0x20(%rbp), %eax
xorl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0xf, -0x14(%rbp)
jne 0x14ab
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x14b7
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x14b9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1469
movl -0x4(%rbp), %eax
shlq $0x20, %rax
movl -0x8(%rbp), %ecx
orq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_decrypt.c
// Function: decrypt_ecb
void decrypt_ecb(FILE *infile, FILE *outfile, uint32_t keys[])
{
  uint32_t left, right;
  size_t ret;
  uint64_t sblock;
  memset(&sblock, 0, sizeof(sblock));
  while(fread(&sblock, sizeof(sblock), 1, infile)){
    left = (sblock>>32);
    right = (sblock<<32)>>32;
    sblock = decrypt(left, right, keys);
    fwrite(&sblock, 1, sizeof(sblock), outfile);
    memset(&sblock, 0, sizeof(sblock));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1080
movq -0x8(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x1040
cmpq $0x0, %rax
je 0x1577
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
shlq $0x20, %rax
shrq $0x20, %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1580
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x1100
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1080
jmp 0x1504
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_decrypt.c
// Function: decrypt
static uint64_t decrypt(uint32_t left, uint32_t right, uint32_t keys[])
{
  uint32_t i, l1, r1;
  for(i= 0; i< ROUNDS; i++){
    r1 = left ^ xor_fun(right, keys[ROUNDS-1-i]);
    l1 = right;
    if(i == ROUNDS -1){
      left = r1;
      right = l1;
    } else {
      left = l1;
      right = r1;
    }
  }
  return (uint64_t)left<<32 | right;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jae 0x15fb
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movl $0xf, %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
callq 0x1700
movl %eax, %ecx
movl -0x20(%rbp), %eax
xorl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0xf, -0x14(%rbp)
jne 0x15e2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x15ee
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x15f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1599
movl -0x4(%rbp), %eax
shlq $0x20, %rax
movl -0x8(%rbp), %ecx
orq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/keymgmt.c
// Function: generateSubKeys
int generateSubKeys(char *key, uint32_t keys[]){
  int k=0;
  if(key==NULL)
    return 0;
  for(int i=0;(i<ROUNDS) &&((key[k] != '\0')||(key[k] != '\n'));i+=2, k++){
    keys[i] = (uint32_t)key[k]^keys[i];
    keys[i+1] = (uint32_t)key[k]^keys[i+1];
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1636
movl $0x0, -0x4(%rbp)
jmp 0x16ee
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x10, -0x20(%rbp)
movb %al, -0x21(%rbp)
jge 0x1679
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
jne 0x1673
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1682
jmp 0x16e7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x163d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/feistal_algo/keymgmt.c
// Function: generateKey
void generateKey(){
  int i=0;
  srand(time(0));
  char key[10]={'\0'};
  while(i!=8){
    key[i] =(char)rand()%256;
    if(inRange(key[i]))
      i++;
  }
  printf("Generated Key: %s\n", key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10c0
movl %eax, %edi
callq 0x1090
leaq -0xe(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1080
cmpl $0x8, -0x4(%rbp)
je 0x178d
callq 0x1110
movsbl %al, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movb %dl, %cl
movslq -0x4(%rbp), %rax
movb %cl, -0xe(%rbp,%rax)
movslq -0x4(%rbp), %rax
movsbl -0xe(%rbp,%rax), %edi
callq 0x17b0
cmpl $0x0, %eax
je 0x178b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x174f
leaq -0xe(%rbp), %rsi
leaq 0xa58(%rip), %rdi       # 0x21f0
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: child
void child(void)
{
	pid_t pid = getpid();

	for (;;) {
		printf("I am child %ld, sleeping for %d sec...\n",
			(long)pid, SLEEP_SEC);
		sleep(SLEEP_SEC);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1030
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xd99(%rip), %rdi       # 0x2004
movl $0x1, %edx
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x1130
jmp 0x1260
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: sigalrm_handler
void sigalrm_handler(int signum)
{
	if (signum != SIGALRM) {
		fprintf(stderr, "Internal error: Called for signum %d, not SIGALRM\n",
			signum);
		exit(1);
	}

	printf("ALARM! %d seconds have passed.\n", ALARM_SEC);

	/* Setup the alarm again */
	if (alarm(ALARM_SEC) < 0) {
		perror("alarm");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0xe, -0x4(%rbp)
je 0x12c6
movq 0x2d50(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0xd77(%rip), %rsi       # 0x202c
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x1120
leaq 0xd92(%rip), %rdi       # 0x205f
movl $0x2, %esi
movb $0x0, %al
callq 0x1060
movl $0x2, %edi
callq 0x1090
cmpl $0x0, %eax
jae 0x12fe
leaq 0xd90(%rip), %rdi       # 0x207f
callq 0x1100
movl $0x1, %edi
callq 0x1120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: sigchld_handler
void sigchld_handler(int signum)
{
	pid_t p;
	int status;

	if (signum != SIGCHLD) {
		fprintf(stderr, "Internal error: Called for signum %d, not SIGCHLD\n",
			signum);
		exit(1);
	}

	/*
	 * Something has happened to one of the children.
	 * We use waitpid() with the WUNTRACED flag, instead of wait(), because
	 * SIGCHLD may have been received for a stopped, not dead child.
	 *
	 * A single SIGCHLD may be received if many processes die at the same time.
	 * We use waitpid() with the WNOHANG flag in a loop, to make sure all
	 * children are taken care of before leaving the handler.
	 */

	for (;;) {
		p = waitpid(-1, &status, WUNTRACED | WNOHANG);
		if (p < 0) {
			perror("waitpid");
			exit(1);
		}
		if (p == 0)
			break;

		explain_wait_status(p, status);

		if (WIFEXITED(status) || WIFSIGNALED(status)) {
			/* A child has died */
			printf("Parent: Received SIGCHLD, child is dead. Exiting.\n");
			exit(0);
		}
		if (WIFSTOPPED(status)) {
			/* A child has stopped due to SIGSTOP/SIGTSTP, etc... */
			printf("Parent: Child has been stopped. Moving right along...\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x11, -0x4(%rbp)
je 0x1346
movq 0x2cd0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0xd50(%rip), %rsi       # 0x2085
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x1120
jmp 0x1348
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0xc(%rbp), %rsi
movl $0x3, %edx
callq 0x10f0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x137a
leaq 0xd4d(%rip), %rdi       # 0x20b8
callq 0x1100
movl $0x1, %edi
callq 0x1120
cmpl $0x0, -0x8(%rbp)
jne 0x1382
jmp 0x13e0
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x15c0
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
je 0x13ab
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x13c0
leaq 0xd0e(%rip), %rdi       # 0x20c0
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x1120
movl -0xc(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x13db
leaq 0xd1f(%rip), %rdi       # 0x20f3
movb $0x0, %al
callq 0x1060
jmp 0x1348
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: main
int main(void)
{
	pid_t p;

	/* Install SIGCHLD handler */
	if (signal(SIGCHLD, sigchld_handler) < 0) {
		perror("signal");
		exit(1);
	}

	/* Install SIGALRM handler */
	if (signal(SIGALRM, sigalrm_handler) < 0) {
		perror("signal");
		exit(1);
	}

	/* Arrange for an alarm after 1 sec */
	if (alarm(ALARM_SEC) < 0) {
		perror("alarm");
		exit(1);
	}

	printf("Parent: Creating child...\n");
	p = fork();
	if (p < 0) {
		/* fork failed */
		perror("fork");
		exit(1);
	}
	if (p == 0) {
		/* In child process */
		child();
		/*
		 * Should never reach this point,
		 * child() does not return
		 */
		assert(0);
	}

	/*
	 * In parent process.
	 */
	
	/*
	 * Do nothing until the child terminates.
	 * The handler will exit().
	 */
	printf("Parent: Created child with PID = %ld, waiting for it to terminate...\n",
		(long)p);
	while (pause())
		;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x11, %edi
leaq -0xfb(%rip), %rsi       # 0x1310
callq 0x10a0
cmpq $0x0, %rax
jae 0x142c
leaq 0xd0d(%rip), %rdi       # 0x212a
callq 0x1100
movl $0x1, %edi
callq 0x1120
movl $0xe, %edi
leaq -0x1a8(%rip), %rsi      # 0x1290
callq 0x10a0
cmpq $0x0, %rax
jae 0x1459
leaq 0xce0(%rip), %rdi       # 0x212a
callq 0x1100
movl $0x1, %edi
callq 0x1120
movl $0x2, %edi
callq 0x1090
cmpl $0x0, %eax
jae 0x147e
leaq 0xc10(%rip), %rdi       # 0x207f
callq 0x1100
movl $0x1, %edi
callq 0x1120
leaq 0xcac(%rip), %rdi       # 0x2131
movb $0x0, %al
callq 0x1060
callq 0x1140
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x14b0
leaq 0xcab(%rip), %rdi       # 0x214c
callq 0x1100
movl $0x1, %edi
callq 0x1120
cmpl $0x0, -0x8(%rbp)
jne 0x14da
callq 0x1250
leaq 0xc8f(%rip), %rdi       # 0x2151
leaq 0xc8a(%rip), %rsi       # 0x2153
movl $0x86, %edx
leaq 0xc90(%rip), %rcx       # 0x2165
callq 0x1080
movslq -0x8(%rbp), %rsi
leaq 0xc8f(%rip), %rdi       # 0x2174
movb $0x0, %al
callq 0x1060
callq 0x10d0
cmpl $0x0, %eax
je 0x14f8
jmp 0x14ec
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/stack_queue.c
// Function: main
int main(void)
{
	struct tt_stack stack = {
		.cap	= LEN,
		.esize	= sizeof(int),
	};

	printf("Testing static stack...\n");
	tt_stack_init(&stack);
	test_stack(&stack);
	tt_stack_free(&stack);
	printf("\n");

	printf("Testing dynamic stack...\n");
	stack.cap = 0;
	tt_stack_init(&stack);
	test_stack(&stack);
	tt_stack_free(&stack);
	printf("\n");

	struct tt_queue queue = {
		.cap	= LEN,
		.esize	= sizeof(int),
	};

	printf("Testing static queue...\n");
	tt_queue_init(&queue);
	test_queue(&queue);
	tt_queue_free(&queue);
	printf("\n");

	printf("Testing dynamic queue...\n");
	queue.cap = 0;
	tt_queue_init(&queue);
	test_queue(&queue);
	tt_queue_free(&queue);
	printf("\n");

	return 0;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movl $0x10, 0x40(%rsp)
movl $0x4, 0x44(%rsp)
leaq 0x4d90(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x1090
leaq 0x40(%rsp), %rdi
callq 0x33c0
leaq 0x40(%rsp), %rdi
callq 0x1390
leaq 0x40(%rsp), %rdi
callq 0x3770
leaq 0x4dc8(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
leaq 0x4d6f(%rip), %rdi      # 0x601d
movb $0x0, %al
callq 0x1090
movl $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x33c0
leaq 0x40(%rsp), %rdi
callq 0x1390
leaq 0x40(%rsp), %rdi
callq 0x3770
leaq 0x4d86(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movl $0x10, 0x8(%rsp)
movl $0x4, 0xc(%rsp)
leaq 0x4d26(%rip), %rdi      # 0x6037
movb $0x0, %al
callq 0x1090
leaq 0x8(%rsp), %rdi
callq 0x3910
leaq 0x8(%rsp), %rdi
callq 0x1430
leaq 0x8(%rsp), %rdi
callq 0x3d40
leaq 0x4d2b(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
leaq 0x4d05(%rip), %rdi      # 0x6050
movb $0x0, %al
callq 0x1090
movl $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3910
leaq 0x8(%rsp), %rdi
callq 0x1430
leaq 0x8(%rsp), %rdi
callq 0x3d40
leaq 0x4ce9(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
xorl %eax, %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/stack_queue.c
// Function: test_stack
static void test_stack(struct tt_stack *stack)
{
	for (int i = 0; i < LEN + 1; i++) {
		int t = i + 1;
		tt_stack_push(stack, &t);
	}
	for (int i = 0; i < LEN + 1; i++) {
		int t;
		if (tt_stack_pop(stack, &t) == 0)
			printf("%d ", t);
	}
	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x11, 0xc(%rsp)
jge 0x13cf
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1530
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x13a1
movl $0x0, 0x4(%rsp)
cmpl $0x11, 0x4(%rsp)
jge 0x1410
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1560
cmpl $0x0, %eax
jne 0x1401
movl (%rsp), %esi
leaq 0x4c70(%rip), %rdi      # 0x606a
movb $0x0, %al
callq 0x1090
jmp 0x1403
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x13d7
leaq 0x4c51(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/stack_queue.c
// Function: test_queue
static void test_queue(struct tt_queue *queue)
{
	int t;
	for (int i = 0; i < LEN + 1; i++) {
		t = i + 1;
		tt_queue_enque(queue, &t);
	}
	for (int i = 0; i < LEN - 1; i++)
		tt_queue_deque(queue, &t);
	for (int i = LEN - 2; i >= 0; i--) {
		t = i + 1;
		tt_queue_enque(queue, &t);
	}

	for (int i = 0; i < LEN + 1; i++) {
		if (tt_queue_deque(queue, &t) == 0)
			printf("%d ", t);
	}
	printf("\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x11, 0x18(%rsp)
jge 0x146f
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x1590
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1441
movl $0x0, 0x14(%rsp)
cmpl $0xf, 0x14(%rsp)
jge 0x149a
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x15c0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1477
movl $0xe, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x14d0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x1590
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x14a2
movl $0x0, 0xc(%rsp)
cmpl $0x11, 0xc(%rsp)
jge 0x1514
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x15c0
cmpl $0x0, %eax
jne 0x1505
movl 0x1c(%rsp), %esi
leaq 0x4b6c(%rip), %rdi      # 0x606a
movb $0x0, %al
callq 0x1090
jmp 0x1507
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x14d8
leaq 0x4b4d(%rip), %rdi      # 0x6068
movb $0x0, %al
callq 0x1090
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: handle_sig
static void handle_sig(int sig) {
  if (flow_pid != -1) kill(flow_pid,SIGTERM);
  if (exec_pid != -1) kill(exec_pid,SIGTERM);
  outf("+++ Fuzzing stopped on signal %d +++\n", sig);
  fclose(outfile);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, 0xdf5e(%rip)     # 0x12230
je 0x42e4
movl 0xdf56(%rip), %edi      # 0x12230
movl $0xf, %esi
callq 0x22c0
cmpl $-0x1, 0xdf49(%rip)     # 0x12234
je 0x42fd
movl 0xdf41(%rip), %edi      # 0x12234
movl $0xf, %esi
callq 0x22c0
jmp 0x42ff
movl -0x4(%rbp), %esi
leaq 0xa433(%rip), %rdi      # 0xe73c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xdfc0(%rip)      # 0x122d8
je 0x4332
movq 0xdfb7(%rip), %rdi      # 0x122d8
movl -0x4(%rbp), %edx
leaq 0xa411(%rip), %rsi      # 0xe73c
movb $0x0, %al
callq 0x22d0
jmp 0x4334
movq 0xdf9d(%rip), %rdi      # 0x122d8
callq 0x21f0
movl $0x1, %edi
callq 0x2250
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: init_random
static void init_random(void) {
  struct timeval tv;
  gettimeofday(&tv,0);
  rand_seed = tv.tv_sec ^ tv.tv_usec ^ (getpid() << 16);
  srandom(rand_seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2350
movq -0x10(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x22f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
shll $0x10, %ecx
movslq %ecx, %rcx
xorq %rcx, %rax
movl %eax, 0xd369(%rip)      # 0x12374
movl 0xd363(%rip), %edi      # 0x12374
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: init_outfile
static void init_outfile(void) {
  _s32 fd;
  _u8* fn = N(out_dir,"BUNNY.log");
  
  unlink(fn);
  fd = open(fn,O_WRONLY|O_CREAT|O_EXCL|O_LARGEFILE,0600);
  if (fd < 0) pfatal("cannot create '%s'",fn);
  outfile = fdopen(fd,"w");
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xd2b1(%rip), %rdi      # 0x122e0
leaq 0x9f3a(%rip), %rsi      # 0xef70
callq 0x7010
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2150
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x5113
jmp 0x506c
jmp 0x506e
movq -0x10(%rbp), %rsi
leaq 0x9f01(%rip), %rdi      # 0xef7a
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xd250(%rip)      # 0x122d8
je 0x50a3
movq 0xd247(%rip), %rdi      # 0x122d8
movq -0x10(%rbp), %rdx
leaq 0x9ede(%rip), %rsi      # 0xef7a
movb $0x0, %al
callq 0x22d0
jmp 0x50a5
jmp 0x50a7
leaq 0x9103(%rip), %rdi      # 0xe1b1
leaq 0x9eee(%rip), %rsi      # 0xefa3
leaq 0x9105(%rip), %rdx      # 0xe1c1
movl $0x126, %ecx            # imm = 0x126
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xd208(%rip)      # 0x122d8
je 0x50fb
movq 0xd1ff(%rip), %rdi      # 0x122d8
leaq 0x90d1(%rip), %rsi      # 0xe1b1
leaq 0x9ebc(%rip), %rdx      # 0xefa3
leaq 0x90d3(%rip), %rcx      # 0xe1c1
movl $0x126, %r8d            # imm = 0x126
movb $0x0, %al
callq 0x22d0
jmp 0x50fd
leaq 0x9eac(%rip), %rdi      # 0xefb0
callq 0x2190
movl $0x1, %edi
callq 0x2250
movl -0x4(%rbp), %edi
leaq 0xa1bb(%rip), %rsi      # 0xf2d8
callq 0x2200
movq %rax, 0xd1af(%rip)      # 0x122d8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: get_queue
static _u8* get_queue(struct bunny_traceitem** ref, _u8* new_af) {
  static _u8* ret = 0;
  _u32 i, skip = 0;;

  if (!queue_real) return 0;

  if (use_qrand) skip = R(queue_real);

  for (i=0;i<queue_len;i++) 
    if (queue_fn[i] && !skip--) break;

  if (ret) free(ret);

  ret = queue_fn[i];
  queue_fn[i] = 0;

  *ref    = queue_ck[i];
  *new_af = queue_af[i];

  queue_real--;

  return ret;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, 0xc1fe(%rip)      # 0x123bc
jne 0x61cd
movq $0x0, -0x8(%rbp)
jmp 0x62ac
cmpb $0x0, 0xc12c(%rip)      # 0x12300
je 0x61eb
callq 0x2120
movl 0xc1db(%rip), %ecx      # 0x123bc
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xc19d(%rip), %eax      # 0x12398
jae 0x622d
movq 0xc19c(%rip), %rax      # 0x123a0
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x6220
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
jne 0x6220
jmp 0x622d
jmp 0x6222
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61f2
cmpq $0x0, 0xc18b(%rip)      # 0x123c0
je 0x6243
movq 0xc182(%rip), %rdi      # 0x123c0
callq 0x2240
movq 0xc156(%rip), %rax      # 0x123a0
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xc168(%rip)      # 0x123c0
movq 0xc141(%rip), %rax      # 0x123a0
movl -0x1c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0xc137(%rip), %rax      # 0x123a8
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0xc12a(%rip), %rax      # 0x123b0
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl 0xc124(%rip), %eax      # 0x123bc
addl $-0x1, %eax
movl %eax, 0xc11b(%rip)      # 0x123bc
movq 0xc118(%rip), %rax      # 0x123c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: N
static _u8* N(_u8* dir, _u8* file) {
  static _u8* fn = 0;
  
  if (fn) free(fn);
  fn = malloc(strlen(dir) + strlen(file) + 2);
  if (!fn) fatal("out of memory");
  
  sprintf(fn,"%s/%s",dir,file);

  return fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x3b3b8(%rip)     # 0x423e0
je 0x7036
movq 0x3b3af(%rip), %rdi     # 0x423e0
callq 0x2240
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq -0x18(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x2280
movq %rax, 0x3b37d(%rip)     # 0x423e0
cmpq $0x0, 0x3b375(%rip)     # 0x423e0
jne 0x7106
jmp 0x7073
jmp 0x7075
leaq 0x7490(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb24d(%rip)      # 0x122d8
je 0x70a2
movq 0xb244(%rip), %rdi      # 0x122d8
leaq 0x7471(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x70a4
jmp 0x70a6
leaq 0x7104(%rip), %rdi      # 0xe1b1
leaq 0x9575(%rip), %rsi      # 0x10629
leaq 0x7106(%rip), %rdx      # 0xe1c1
movl $0x100, %ecx            # imm = 0x100
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb209(%rip)      # 0x122d8
je 0x70fa
movq 0xb200(%rip), %rdi      # 0x122d8
leaq 0x70d2(%rip), %rsi      # 0xe1b1
leaq 0x9543(%rip), %rdx      # 0x10629
leaq 0x70d4(%rip), %rcx      # 0xe1c1
movl $0x100, %r8d            # imm = 0x100
movb $0x0, %al
callq 0x22d0
jmp 0x70fc
movl $0x1, %edi
callq 0x2250
movq 0x3b2d3(%rip), %rdi     # 0x423e0
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x825f(%rip), %rsi      # 0xf37b
movb $0x0, %al
callq 0x2060
movq 0x3b2b6(%rip), %rax     # 0x423e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: point_inflow
static void point_inflow(_u8* target_dir) {
  if (!inflow_dir) fatal("inflow_dir is NULL");
  unlink(inflow_dir); /* Ignore errors */
  if (!target_dir) target_dir = in_dir;
  if (symlink(Ncanon(target_dir),inflow_dir)) 
    pfatal("unable to symlink %s -> %s",target_dir,inflow_dir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xb234(%rip)      # 0x12378
jne 0x71df
jmp 0x714c
jmp 0x714e
leaq 0x81b7(%rip), %rdi      # 0xf30c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb174(%rip)      # 0x122d8
je 0x717b
movq 0xb16b(%rip), %rdi      # 0x122d8
leaq 0x8198(%rip), %rsi      # 0xf30c
movb $0x0, %al
callq 0x22d0
jmp 0x717d
jmp 0x717f
leaq 0x702b(%rip), %rdi      # 0xe1b1
leaq 0x81a9(%rip), %rsi      # 0xf336
leaq 0x702d(%rip), %rdx      # 0xe1c1
movl $0x18c, %ecx            # imm = 0x18C
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb130(%rip)      # 0x122d8
je 0x71d3
movq 0xb127(%rip), %rdi      # 0x122d8
leaq 0x6ff9(%rip), %rsi      # 0xe1b1
leaq 0x8177(%rip), %rdx      # 0xf336
leaq 0x6ffb(%rip), %rcx      # 0xe1c1
movl $0x18c, %r8d            # imm = 0x18C
movb $0x0, %al
callq 0x22d0
jmp 0x71d5
movl $0x1, %edi
callq 0x2250
movq 0xb192(%rip), %rdi      # 0x12378
callq 0x2110
cmpq $0x0, -0x8(%rbp)
jne 0x71fd
movq 0xb0d7(%rip), %rax      # 0x122d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
movq 0xb168(%rip), %rsi      # 0x12378
callq 0x2040
cmpl $0x0, %eax
je 0x72d5
jmp 0x7220
jmp 0x7222
movq -0x8(%rbp), %rsi
movq 0xb14b(%rip), %rdx      # 0x12378
leaq 0x810f(%rip), %rdi      # 0xf343
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb095(%rip)      # 0x122d8
je 0x7265
movq 0xb08c(%rip), %rdi      # 0x122d8
movq -0x8(%rbp), %rdx
movq 0xb121(%rip), %rcx      # 0x12378
leaq 0x80e5(%rip), %rsi      # 0xf343
movb $0x0, %al
callq 0x22d0
jmp 0x7267
jmp 0x7269
leaq 0x6f41(%rip), %rdi      # 0xe1b1
leaq 0x80bf(%rip), %rsi      # 0xf336
leaq 0x6f43(%rip), %rdx      # 0xe1c1
movl $0x190, %ecx            # imm = 0x190
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xb046(%rip)      # 0x122d8
je 0x72bd
movq 0xb03d(%rip), %rdi      # 0x122d8
leaq 0x6f0f(%rip), %rsi      # 0xe1b1
leaq 0x808d(%rip), %rdx      # 0xf336
leaq 0x6f11(%rip), %rcx      # 0xe1c1
movl $0x190, %r8d            # imm = 0x190
movb $0x0, %al
callq 0x22d0
jmp 0x72bf
leaq 0x7cea(%rip), %rdi      # 0xefb0
callq 0x2190
movl $0x1, %edi
callq 0x2250
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: Ncanon
static _u8* Ncanon( _u8* file) {
  static _u8* fn = 0;
  static char* cwd = 0;
  
  if (file[0] == '/') return file;
  
  if (!cwd) { 
    cwd = getcwd(0,MAXTOKEN);
    if (!cwd) fatal("out of memory");
  }
  
  if (fn) free(fn);
  fn = malloc(strlen(cwd) + strlen(file) + 2);
  if (!fn) fatal("out of memory");
  
  sprintf(fn,"%s/%s",cwd,file);

  return fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7985
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7b61
cmpq $0x0, 0xaa03(%rip)      # 0x12390
jne 0x7a4d
xorl %eax, %eax
movl %eax, %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2130
movq %rax, 0xa9e8(%rip)      # 0x12390
cmpq $0x0, 0xa9e0(%rip)      # 0x12390
jne 0x7a4b
jmp 0x79b8
jmp 0x79ba
leaq 0x6b4b(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa908(%rip)      # 0x122d8
je 0x79e7
movq 0xa8ff(%rip), %rdi      # 0x122d8
leaq 0x6b2c(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x79e9
jmp 0x79eb
leaq 0x67bf(%rip), %rdi      # 0xe1b1
leaq 0x797b(%rip), %rsi      # 0xf374
leaq 0x67c1(%rip), %rdx      # 0xe1c1
movl $0x112, %ecx            # imm = 0x112
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa8c4(%rip)      # 0x122d8
je 0x7a3f
movq 0xa8bb(%rip), %rdi      # 0x122d8
leaq 0x678d(%rip), %rsi      # 0xe1b1
leaq 0x7949(%rip), %rdx      # 0xf374
leaq 0x678f(%rip), %rcx      # 0xe1c1
movl $0x112, %r8d            # imm = 0x112
movb $0x0, %al
callq 0x22d0
jmp 0x7a41
movl $0x1, %edi
callq 0x2250
jmp 0x7a4d
cmpq $0x0, 0xa933(%rip)      # 0x12388
je 0x7a63
movq 0xa92a(%rip), %rdi      # 0x12388
callq 0x2240
movq 0xa926(%rip), %rdi      # 0x12390
callq 0x20f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq -0x18(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x2280
movq %rax, 0xa8f5(%rip)      # 0x12388
cmpq $0x0, 0xa8ed(%rip)      # 0x12388
jne 0x7b36
jmp 0x7aa3
jmp 0x7aa5
leaq 0x6a60(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa81d(%rip)      # 0x122d8
je 0x7ad2
movq 0xa814(%rip), %rdi      # 0x122d8
leaq 0x6a41(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x7ad4
jmp 0x7ad6
leaq 0x66d4(%rip), %rdi      # 0xe1b1
leaq 0x7890(%rip), %rsi      # 0xf374
leaq 0x66d6(%rip), %rdx      # 0xe1c1
movl $0x117, %ecx            # imm = 0x117
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa7d9(%rip)      # 0x122d8
je 0x7b2a
movq 0xa7d0(%rip), %rdi      # 0x122d8
leaq 0x66a2(%rip), %rsi      # 0xe1b1
leaq 0x785e(%rip), %rdx      # 0xf374
leaq 0x66a4(%rip), %rcx      # 0xe1c1
movl $0x117, %r8d            # imm = 0x117
movb $0x0, %al
callq 0x22d0
jmp 0x7b2c
movl $0x1, %edi
callq 0x2250
movq 0xa84b(%rip), %rdi      # 0x12388
movq 0xa84c(%rip), %rdx      # 0x12390
movq -0x10(%rbp), %rcx
leaq 0x782c(%rip), %rsi      # 0xf37b
movb $0x0, %al
callq 0x2060
movq 0xa82b(%rip), %rax      # 0x12388
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: discard_context
static void discard_context(struct bunny_traceitem* t, _u8 free_t) {
  _u32 i;

  if (!t->param_data) fatal("context freed more than once");

  free(t->param_data);
  free(t->param_range);
  free(t->param_chgmap);
    
  /* To detect access... */
  t->param_data  = 0;
  t->param_range = 0;

  for (i=0;i<t->param_count;i++) FREEINT2(t->eff[i]);

  free(t->eff);
  t->eff = 0;

  FREEINT(t->has_eff);

  if (t->fault_loc) free(t->fault_loc);

  if (free_t) free(t);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x8626
jmp 0x8593
jmp 0x8595
leaq 0x7a26(%rip), %rdi      # 0xffc2
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x9d2d(%rip)      # 0x122d8
je 0x85c2
movq 0x9d24(%rip), %rdi      # 0x122d8
leaq 0x7a07(%rip), %rsi      # 0xffc2
movb $0x0, %al
callq 0x22d0
jmp 0x85c4
jmp 0x85c6
leaq 0x5be4(%rip), %rdi      # 0xe1b1
leaq 0x7a22(%rip), %rsi      # 0xfff6
leaq 0x5be6(%rip), %rdx      # 0xe1c1
movl $0x31b, %ecx            # imm = 0x31B
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x9ce9(%rip)      # 0x122d8
je 0x861a
movq 0x9ce0(%rip), %rdi      # 0x122d8
leaq 0x5bb2(%rip), %rsi      # 0xe1b1
leaq 0x79f0(%rip), %rdx      # 0xfff6
leaq 0x5bb4(%rip), %rcx      # 0xe1c1
movl $0x31b, %r8d            # imm = 0x31B
movb $0x0, %al
callq 0x22d0
jmp 0x861c
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2240
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2240
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2240
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x86f0
jmp 0x867a
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x86a6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x86be
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x86e2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x866c
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2240
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x872b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8759
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2240
cmpb $0x0, -0x9(%rbp)
je 0x8768
movq -0x8(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nop