LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: string_resize
static unsigned string_resize(char** out, size_t size)
{
  char* data = (char*)lodepng_realloc(*out, size + 1);
  if(data)
  {
    data[size] = 0; /*null termination char*/
    *out = data;
  }
  return data != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x2cc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe026
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readBitsFromReversedStream
static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
{
  unsigned result = 0;
  size_t i;
  for(i = 0 ; i < nbits; ++i)
  {
    result <<= 1;
    result |= (unsigned)readBitFromReversedStream(bitpointer, bitstream);
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe099
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0b0
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xe063
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: addColorBits
static void addColorBits(unsigned char* out, size_t index, unsigned bits, unsigned in)
{
  unsigned m = bits == 1 ? 7 : bits == 2 ? 3 : 1; /*8 / bits - 1*/
  /*p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half*/
  unsigned p = index & m;
  in &= (1u << bits) - 1u; /*filter out any other bits of the input value*/
  in = in << (bits * (m - p));
  if(p == 0) out[index * bits / 8] = in;
  else out[index * bits / 8] |= in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0xe122
movl $0x7, %eax
movl %eax, -0x24(%rbp)
jmp 0xe138
movl -0x14(%rbp), %edx
movl $0x1, %eax
movl $0x3, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
andq %rcx, %rax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
movl -0x1c(%rbp), %edx
subl -0x20(%rbp), %edx
imull %edx, %ecx
shll %cl, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xe195
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %esi
imulq %rsi, %rcx
shrq $0x3, %rcx
movb %dl, (%rax,%rcx)
jmp 0xe1b4
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
imulq %rdx, %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: color_tree_get
static int color_tree_get(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  int bit = 0;
  for(bit = 0; bit < 8; ++bit)
  {
    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
    if(!tree->children[i]) return -1;
    else tree = tree->children[i];
  }
  return tree ? tree->index : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xe272
movzbl -0x11(%rbp), %eax
movl -0x18(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
shll $0x3, %eax
movzbl -0x12(%rbp), %edx
movl -0x18(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl -0x13(%rbp), %edx
movl -0x18(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll %ecx
addl %ecx, %eax
movzbl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xe252
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe298
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xe264
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe1e6
cmpq $0x0, -0x10(%rbp)
je 0xe288
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xe292
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0xe292
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readChunk_PLTE
static unsigned readChunk_PLTE(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
{
  unsigned pos = 0, i;
  if(color->palette) lodepng_free(color->palette);
  color->palettesize = chunkLength / 3;
  color->palette = (unsigned char*)lodepng_malloc(4 * color->palettesize);
  if(!color->palette && color->palettesize)
  {
    color->palettesize = 0;
    return 83; /*alloc fail*/
  }
  if(color->palettesize > 256) return 38; /*error: palette too big*/

  for(i = 0; i != color->palettesize; ++i)
  {
    color->palette[4 * i + 0] = data[pos++]; /*R*/
    color->palette[4 * i + 1] = data[pos++]; /*G*/
    color->palette[4 * i + 2] = data[pos++]; /*B*/
    color->palette[4 * i + 3] = 255; /*alpha*/
  }

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe2d3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1e60
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x13b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe336
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe336
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x53, -0x4(%rbp)
jmp 0xe412
movq -0x10(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jbe 0xe350
movl $0x26, -0x4(%rbp)
jmp 0xe412
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xe40b
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe357
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readChunk_tRNS
static unsigned readChunk_tRNS(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
{
  unsigned i;
  if(color->colortype == LCT_PALETTE)
  {
    /*error: more alpha values given than there are palette entries*/
    if(chunkLength > color->palettesize) return 38;

    for(i = 0; i != chunkLength; ++i) color->palette[4 * i + 3] = data[i];
  }
  else if(color->colortype == LCT_GREY)
  {
    /*error: this chunk must be 2 bytes for greyscale image*/
    if(chunkLength != 2) return 30;

    color->key_defined = 1;
    color->key_r = color->key_g = color->key_b = 256u * data[0] + data[1];
  }
  else if(color->colortype == LCT_RGB)
  {
    /*error: this chunk must be 6 bytes for RGB image*/
    if(chunkLength != 6) return 41;

    color->key_defined = 1;
    color->key_r = 256u * data[0] + data[1];
    color->key_g = 256u * data[2] + data[3];
    color->key_b = 256u * data[4] + data[5];
  }
  else return 42; /*error: tRNS chunk not allowed for other color models*/

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xe493
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xe453
movl $0x26, -0x4(%rbp)
jmp 0xe575
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
je 0xe48e
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe45a
jmp 0xe56e
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xe4e8
cmpq $0x2, -0x20(%rbp)
je 0xe4af
movl $0x1e, -0x4(%rbp)
jmp 0xe575
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0xe56c
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xe561
cmpq $0x6, -0x20(%rbp)
je 0xe501
movl $0x29, -0x4(%rbp)
jmp 0xe575
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe56a
movl $0x2a, -0x4(%rbp)
jmp 0xe575
jmp 0xe56c
jmp 0xe56e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readChunk_bKGD
static unsigned readChunk_bKGD(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(info->color.colortype == LCT_PALETTE)
  {
    /*error: this chunk must be 1 byte for indexed color image*/
    if(chunkLength != 1) return 43;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = data[0];
  }
  else if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
  {
    /*error: this chunk must be 2 bytes for greyscale image*/
    if(chunkLength != 2) return 44;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = 256u * data[0] + data[1];
  }
  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
  {
    /*error: this chunk must be 6 bytes for greyscale image*/
    if(chunkLength != 6) return 45;

    info->background_defined = 1;
    info->background_r = 256u * data[0] + data[1];
    info->background_g = 256u * data[2] + data[3];
    info->background_b = 256u * data[4] + data[5];
  }

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xe5d9
cmpq $0x1, -0x20(%rbp)
je 0xe5ad
movl $0x2b, -0x4(%rbp)
jmp 0xe6c6
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
jmp 0xe6bf
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xe5ed
movq -0x10(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xe639
cmpq $0x2, -0x20(%rbp)
je 0xe600
movl $0x2c, -0x4(%rbp)
jmp 0xe6c6
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
jmp 0xe6bd
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0xe64d
movq -0x10(%rbp), %rax
cmpl $0x6, 0x10(%rax)
jne 0xe6bb
cmpq $0x6, -0x20(%rbp)
je 0xe65d
movl $0x2d, -0x4(%rbp)
jmp 0xe6c6
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44(%rax)
jmp 0xe6bd
jmp 0xe6bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readChunk_tIME
static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(chunkLength != 7) return 73; /*invalid tIME chunk size*/

  info->time_defined = 1;
  info->time.year = 256u * data[0] + data[1];
  info->time.month = data[2];
  info->time.day = data[3];
  info->time.hour = data[4];
  info->time.minute = data[5];
  info->time.second = data[6];

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x7, -0x20(%rbp)
je 0xeea3
movl $0x49, -0x4(%rbp)
jmp 0xef30
movq -0x10(%rbp), %rax
movl $0x1, 0x88(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x94(%rax)
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x9c(%rax)
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: readChunk_pHYs
static unsigned readChunk_pHYs(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(chunkLength != 9) return 74; /*invalid pHYs chunk size*/

  info->phys_defined = 1;
  info->phys_x = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3];
  info->phys_y = 16777216u * data[4] + 65536u * data[5] + 256u * data[6] + data[7];
  info->phys_unit = data[8];

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x9, -0x20(%rbp)
je 0xef63
movl $0x4a, -0x4(%rbp)
jmp 0xeffb
movq -0x10(%rbp), %rax
movl $0x1, 0xa4(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xac(%rax)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: unfilter
static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
{
  /*
  For PNG filter method 0
  this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times)
  out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline
  w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel
  in and out are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes)
  */

  unsigned y;
  unsigned char* prevline = 0;

  /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
  size_t bytewidth = (bpp + 7) / 8;
  size_t linebytes = (w * bpp + 7) / 8;

  for(y = 0; y < h; ++y)
  {
    size_t outindex = linebytes * y;
    size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
    unsigned char filterType = in[inindex];

    CERROR_TRY_RETURN(unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes));

    prevline = &out[outindex];
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
imull -0x24(%rbp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xf451
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movl -0x28(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x51(%rbp)
movq -0x10(%rbp), %rdi
addq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x50(%rbp), %rax
addq $0x1, %rax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movb -0x51(%rbp), %al
movq -0x40(%rbp), %r9
movzbl %al, %r8d
callq 0xfb30
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
je 0xf437
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf458
movq -0x10(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf3bb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: removePaddingBits
static void removePaddingBits(unsigned char* out, const unsigned char* in,
                              size_t olinebits, size_t ilinebits, unsigned h)
{
  /*
  After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need
  to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers
  for the Adam7 code, the color convert code and the output to the user.
  in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must
  have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
  also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
  only useful if (ilinebits - olinebits) is a value in the range 1..7
  */
  unsigned y;
  size_t diff = ilinebits - olinebits;
  size_t ibp = 0, obp = 0; /*input and output bit pointers*/
  for(y = 0; y < h; ++y)
  {
    size_t x;
    for(x = 0; x < olinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    ibp += diff;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xf50f
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xf4f8
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe0b0
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movzbl -0x49(%rbp), %edx
callq 0x10030
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xf4bf
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf4af
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: paethPredictor
static unsigned char paethPredictor(short a, short b, short c)
{
  short pa = abs(b - c);
  short pb = abs(a - c);
  short pc = abs(a + b - c - c);

  if(pc < pa && pc < pb) return (unsigned char)c;
  else if(pb < pa) return (unsigned char)b;
  else return (unsigned char)a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movswl -0x6(%rbp), %eax
movswl -0x8(%rbp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xa(%rbp)
movswl -0x4(%rbp), %eax
movswl -0x8(%rbp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xc(%rbp)
movswl -0x4(%rbp), %eax
movswl -0x6(%rbp), %ecx
addl %ecx, %eax
movswl -0x8(%rbp), %ecx
subl %ecx, %eax
movswl -0x8(%rbp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x10005
movswl -0xe(%rbp), %eax
movswl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x10005
movw -0x8(%rbp), %ax
movb %al, -0x1(%rbp)
jmp 0x10021
movswl -0xc(%rbp), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1001a
movw -0x6(%rbp), %ax
movb %al, -0x1(%rbp)
jmp 0x10021
movw -0x4(%rbp), %ax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: addPaddingBits
static void addPaddingBits(unsigned char* out, const unsigned char* in,
                           size_t olinebits, size_t ilinebits, unsigned h)
{
  /*The opposite of the removePaddingBits function
  olinebits must be >= ilinebits*/
  unsigned y;
  size_t diff = olinebits - ilinebits;
  size_t obp = 0, ibp = 0; /*bit pointers*/
  for(y = 0; y != h; ++y)
  {
    size_t x;
    for(x = 0; x < ilinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    /*obp += diff; --> no, fill in some value in the padding bits too, to avoid
    "Use of uninitialised value of size ###" warning from valgrind*/
    for(x = 0; x != diff; ++x) setBitOfReversedStream(&obp, out, 0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x101fb
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x101bc
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xe0b0
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movzbl -0x49(%rbp), %edx
callq 0x10030
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x10183
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x101eb
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x10030
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x101c4
jmp 0x101ed
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1016f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: flog2
static float flog2(float f)
{
  float result = 0;
  while(f > 32) { result += 4; f /= 16; }
  while(f > 2) { ++result; f /= 2; }
  return result + 1.442695f * (f * f * f / 3 - 3 * f * f / 2 + 3 * f - 1.83333f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x2f72(%rip), %xmm1     # 0x14510
ucomiss %xmm1, %xmm0
jbe 0x115cd
movss 0x2f7d(%rip), %xmm0     # 0x14528
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x2f62(%rip), %xmm1     # 0x14524
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x11591
jmp 0x115cf
movss -0x4(%rbp), %xmm0
movss 0x2f38(%rip), %xmm1     # 0x14514
ucomiss %xmm1, %xmm0
jbe 0x1160b
movss 0x2f23(%rip), %xmm0     # 0x1450c
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x2f14(%rip), %xmm1     # 0x14514
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x115cf
movss -0x8(%rbp), %xmm1
movss -0x4(%rbp), %xmm2
mulss -0x4(%rbp), %xmm2
mulss -0x4(%rbp), %xmm2
movss 0x2ef9(%rip), %xmm0     # 0x14520
divss %xmm0, %xmm2
movss 0x2eed(%rip), %xmm0     # 0x14520
mulss -0x4(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss 0x2ecf(%rip), %xmm3     # 0x14514
divss %xmm3, %xmm0
subss %xmm0, %xmm2
movss -0x4(%rbp), %xmm0
movss 0x2ec6(%rip), %xmm3     # 0x14520
mulss %xmm3, %xmm0
addss %xmm2, %xmm0
movss 0x2eb2(%rip), %xmm2     # 0x1451c
subss %xmm2, %xmm0
movss 0x2ea2(%rip), %xmm2     # 0x14518
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/txp-convert.c
// Function: swizzle
int swizzle(int index) {
	int b = (index >> 3) & 3;
	if( b == 1 ) b = 2;
	else if( b == 2 ) b = 1;
	int swiz = b * 8;
	int b32 = (index >> 5 ) * 32;
	int final = b32 + swiz + (index & 7 );
	return final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
sarl $0x3, %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11782
movl $0x2, -0x8(%rbp)
jmp 0x11791
cmpl $0x2, -0x8(%rbp)
jne 0x1178f
movl $0x1, -0x8(%rbp)
jmp 0x11791
movl -0x8(%rbp), %eax
shll $0x3, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
sarl $0x5, %eax
shll $0x5, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
andl $0x7, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/txp-convert.c
// Function: buildPalette
paletteEntry *buildPalette(unsigned char *source, unsigned int bpp) {
	paletteEntry *retpal = NULL;
	unsigned int palsize;
	palsize = (bpp==4) ? 16:256;
	retpal = malloc(sizeof(paletteEntry)*palsize);
	unsigned int i, e = 0;
	for(i = 0; i < palsize; i++) {
		retpal[i].red = source[e];
		e++;
		retpal[i].green = source[e];
		e++;
		retpal[i].blue = source[e];
		e++;
		retpal[i].alpha = source[e];
		e++;
	}
	return retpal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %edx
movl $0x100, %eax            # imm = 0x100
movl $0x10, %ecx
cmpl $0x4, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x10d0
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x129ee
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb %dl, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb %dl, 0x1(%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb %dl, 0x2(%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb %dl, 0x3(%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1295d
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/txp-convert.c
// Function: buildSingleFrameRgba
unsigned char *buildSingleFrameRgba(textureHeader *textures, frameHeader frame) {
	unsigned int x, y, mempointer = 0, framesize = frame.width * frame.height;
	unsigned char *retframe = malloc(framesize * 4), pixel;
	for(y = frame.sourcey; y < frame.sourcey+frame.height; y++) {
		for(x = frame.sourcex; x < frame.sourcex+frame.width; x++) {
			pixel = frame.texpixels[x+y*textures[frame.sourcetexture].width];
			retframe[mempointer] = frame.palpixels[pixel].red;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].green;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].blue;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].alpha;
			mempointer++;
		}
	}
	return retframe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl 0x4(%rcx), %eax
imull 0x8(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x30(%rbp), %rdx
movl -0x10(%rbp), %eax
movl 0x10(%rdx), %ecx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x13133
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x30(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0xc(%rdx), %ecx
addl 0x4(%rdx), %ecx
cmpl %ecx, %eax
jae 0x13123
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdi
movl 0x14(%rax), %r8d
imulq $0x28, %r8, %r8
addq %r8, %rdi
imull 0x8(%rdi), %esi
addl %esi, %edx
movl %edx, %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x21(%rbp)
movq 0x28(%rax), %rcx
movzbl -0x21(%rbp), %edx
movb (%rcx,%rdx,4), %sil
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movb %sil, (%rcx,%rdx)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movq 0x28(%rax), %rcx
movzbl -0x21(%rbp), %edx
movb 0x1(%rcx,%rdx,4), %sil
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movb %sil, (%rcx,%rdx)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movq 0x28(%rax), %rcx
movzbl -0x21(%rbp), %edx
movb 0x2(%rcx,%rdx,4), %sil
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movb %sil, (%rcx,%rdx)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movq 0x28(%rax), %rax
movzbl -0x21(%rbp), %ecx
movb 0x3(%rax,%rcx,4), %dl
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13054
jmp 0x13125
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13035
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/tracegen.c
// Function: validate
int validate(int fn,int M, int N, int A[N][M], int B[M][N]) {
    int C[M][N];
    memset(C,0,sizeof(C));
    correctTrans(M,N,A,C);
    for(int i=0;i<M;i++) {
        for(int j=0;j<N;j++) {
            if(B[i][j]!=C[i][j]) {
                printf("Validation failed on function %d! Expected %d but got %d at B[%d][%d]\n",fn,C[i][j],B[i][j],i,j);
                return 0;
            }
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %esi
movq %rsi, -0x60(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edx
movq %rsi, %rax
movq %rax, -0x58(%rbp)
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rdx, %rcx
imulq %rsi, %rcx
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rsp
movq %rdx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
imulq %rax, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1060
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x5780
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1358
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1348
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rdx
imulq %rdi, %rdx
shlq $0x2, %rdx
addq %rdx, %rax
movslq -0x40(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movslq -0x3c(%rbp), %rdx
imulq %rsi, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x40(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x1338
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rdx
movl -0x8(%rbp), %esi
movslq -0x3c(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq %rdi, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl -0x3c(%rbp), %r8d
movl -0x40(%rbp), %r9d
leaq 0x4d23(%rip), %rdi      # 0x6044
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x1366
jmp 0x133a
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1289
jmp 0x134a
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1276
movl $0x1, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/cachelab.c
// Function: printSummary
void printSummary(int hits, int misses, int evictions)
{
    printf("hits:%d misses:%d evictions:%d\n", hits, misses, evictions);
    FILE* output_fp = fopen(".csim_results", "w");
    assert(output_fp);
    fprintf(output_fp, "%d %d %d\n", hits, misses, evictions);
    fclose(output_fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0xb4a(%rip), %rdi       # 0x60fb
movb $0x0, %al
callq 0x1040
leaq 0xb5c(%rip), %rdi       # 0x611b
leaq 0xafd(%rip), %rsi       # 0x60c3
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x55d8
jmp 0x55f7
leaq 0xb4a(%rip), %rdi       # 0x6129
leaq 0xb4d(%rip), %rsi       # 0x6133
movl $0x15, %edx
leaq 0xb4c(%rip), %rcx       # 0x613e
callq 0x1050
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0xb53(%rip), %rsi       # 0x615f
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/cachelab.c
// Function: initMatrix
void initMatrix(int M, int N, int A[N][M], int B[M][N])
{
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
            B[j][i]=rand();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x56e4
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x56d7
callq 0x10e0
movq -0x30(%rbp), %rsi
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rsi, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
callq 0x10e0
movq -0x28(%rbp), %rsi
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq %rsi, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x567a
jmp 0x56d9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x566b
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/cachelab.c
// Function: randMatrix
void randMatrix(int M, int N, int A[N][M]) {
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5774
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5767
callq 0x10e0
movq -0x20(%rbp), %rsi
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq %rsi, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x572f
jmp 0x5769
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5720
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/cachelab.c
// Function: correctTrans
void correctTrans(int M, int N, int A[N][M], int B[M][N])
{
    int i, j, tmp;
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            tmp = A[i][j];
            B[j][i] = tmp;
        }
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x38(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5818
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x580b
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq %rsi, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57b6
jmp 0x580d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57a7
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/cachelab.c
// Function: registerTransFunction
void registerTransFunction(void (*trans)(int M, int N, int[N][M], int[M][N]), 
                           char* desc)
{
    func_list[func_counter].func_ptr = trans;
    func_list[func_counter].description = desc;
    func_list[func_counter].correct = 0;
    func_list[func_counter].num_hits = 0;
    func_list[func_counter].num_misses = 0;
    func_list[func_counter].num_evictions =0;
    func_counter++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movslq 0x82b49(%rip), %rdx     # 0x88380
leaq 0x82b52(%rip), %rax     # 0x88390
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movslq 0x82b2d(%rip), %rdx     # 0x88380
leaq 0x82b36(%rip), %rax     # 0x88390
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movslq 0x82b14(%rip), %rcx     # 0x88380
leaq 0x82b1d(%rip), %rax     # 0x88390
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x0, 0x10(%rax)
movslq 0x82afb(%rip), %rcx     # 0x88380
leaq 0x82b04(%rip), %rax     # 0x88390
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x14(%rax)
movslq 0x82adf(%rip), %rcx     # 0x88380
leaq 0x82ae8(%rip), %rax     # 0x88390
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x18(%rax)
movslq 0x82ac3(%rip), %rcx     # 0x88380
leaq 0x82acc(%rip), %rax     # 0x88390
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
movl 0x82aa8(%rip), %eax     # 0x88380
addl $0x1, %eax
movl %eax, 0x82a9f(%rip)     # 0x88380
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceProgram
int ReduceProgram(SYNTAX_TREE* node)
{
    SYNTAX_TREE* gstmt_1 = node->children[0];
    Assert(node->numChildren == 1);

    int error = 0;
    error = (error ? error : ProcessNode(gstmt_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2240
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x224c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceGstmtStarA
int ReduceGstmtStarA(SYNTAX_TREE* node)
{
    SYNTAX_TREE* gstmt1 = node->children[0];
    SYNTAX_TREE* gstmt_1 = node->children[1];
    Assert(node->numChildren == 2);

    int error = 0;
    error = (error ? error : ProcessNode(gstmt1));
    error = (error ? error : ProcessNode(gstmt_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x27a0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x27ac
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x27c0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x27cc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceGstmtA
int ReduceGstmtA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* string_list1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(string_list1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2831
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x283d
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceStringListA
int ReduceStringListA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* string1 = node->children[0];
    SYNTAX_TREE* string_list1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(string1));
    error = (error ? error : ProcessNode(string_list1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2890
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x289c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x28b0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x28bc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceStringListB
int ReduceStringListB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* string1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(string1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2900
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x290c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceGstmtB
int ReduceGstmtB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* type_declaration1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(type_declaration1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2950
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x295c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceTypeDeclarationA
int ReduceTypeDeclarationA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* type_declaration1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(type_declaration1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29b0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x29bc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29d0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x29dc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)