LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/umatin[P]LogarithmicErrorRegression/./src/error_function.h
// Function: long double calculate_error<(ERROR_TYPE)0, true, true>(std::vector<double, std::allocator<double>>&, double, double)
long double calculate_error(std::vector<double>& data, double a, double b){
    long double total_error = 0;
    for(long i = 0; i < data.size(); i++){
        total_error += calculate_error_single_element<E, CORRECT, BOUNDED>(data, a, b, i);
    }
    return total_error;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
movq %rdi, %rbx
xorl %r14d, %r14d
fldz
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r14
jae 0x81a8
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
movl %r14d, %esi
fstpt 0x1c(%rsp)
callq 0x81b0
fldt 0x1c(%rsp)
vmovsd %xmm0, 0x10(%rsp)
incq %r14
faddl 0x10(%rsp)
jmp 0x816b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/continued-fractions.h
// Function: efgy::math::numeric::continuedFractional<long long>::continuedFractional(efgy::math::numeric::fractional<long long> const&)
continuedFractional(const fractional<N> &pF)
      : coefficient(), negative(false) {
    N i = N(0);
    for (fractional<N> f = pF;
         (f.numerator != zero()) && (f.denominator != zero());
         f = reciprocal(f - i)) {
      i = N(f);

      if (i < zero()) {
        coefficient.push_back(-i);
        negative = true;
      } else {
        coefficient.push_back(i);
      }

      if (f < zero()) {
        f *= N(-1);
        i = -i;
      }
    }

    if ((coefficient.size() > one()) && (coefficient.back() == N(1))) {
      coefficient.push_back(N(1));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movups (%rsi), %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq (%r15), %rax
leaq 0x28(%rsp), %r12
testq %rax, %rax
je 0x5248
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0x5248
cqto
idivq %rcx
movq %rax, 0x8(%rsp)
testq %rax, %rax
js 0x51e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f0a
jmp 0x51f7
negq %rax
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11fb4
movb $0x1, 0x18(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x121f1
testb %al, %al
je 0x521c
orq $-0x1, 0x28(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x11f2a
negq 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x11f7e
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r12, %rdi
callq 0x11f42
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
jmp 0x51ad
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq (%rbx), %rcx
cmpq $0x8, %rcx
jbe 0x5273
cmpq $0x1, -0x8(%rax)
jne 0x5273
leaq 0x10(%rsp), %rsi
movq $0x1, (%rsi)
movq %rbx, %rdi
callq 0x11fb4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5289
jmp 0x5289
jmp 0x5289
jmp 0x5289
jmp 0x5289
movq %rax, %r14
movq %rbx, %rdi
callq 0xf4b8
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/continued-fractions.h
// Function: efgy::math::numeric::continuedFractional<long long>::operator efgy::math::numeric::fractional<long long>() const
operator fractional<N>(void) const {
    fractional<N> rv;
    N j = coefficient.size() - N(1);
    for (N i = j; i >= N(0); i--) {
      if (i == j) {
        rv = fractional<N>(N(coefficient[i]));
      } else {
        rv = reciprocal(rv) + coefficient[i];
      }
    }
    if (negative) {
      rv *= N(-1);
    }
    return rv;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
movq $0x1, 0x8(%rax)
movq 0x8(%rdi), %r12
subq (%rdi), %r12
movq %r12, %r13
sarq $0x3, %r13
leaq -0x1(%r13), %rbp
addq $-0x8, %r12
pushq $0x1
popq %r14
xorl %r15d, %r15d
movq %r14, %rdx
xorl %eax, %eax
movq %rbp, %rcx
addq %r15, %rcx
js 0x5403
subq $0x1, %r15
jae 0x53cf
movq (%rbx), %rax
movq -0x8(%rax,%r13,8), %rax
movq %r14, %rdx
jmp 0x53f3
leaq 0x8(%rsp), %rdi
callq 0x11f42
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq (%rbx), %rsi
addq %r12, %rsi
leaq 0x18(%rsp), %rdi
callq 0x12a00
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
addq $-0x8, %r12
jmp 0x53b4
cmpb $0x0, 0x18(%rbx)
je 0x5426
leaq 0x18(%rsp), %rsi
orq $-0x1, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x11f2a
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/continued-fractions.h
// Function: std::basic_ostream<char, std::char_traits<char>>& efgy::math::numeric::operator<<<char, long long>(std::basic_ostream<char, std::char_traits<char>>&, efgy::math::numeric::continuedFractional<long long> const&)
std::basic_ostream<C> &operator<<(std::basic_ostream<C> &out,
                                  const continuedFractional<N> &f) {
  if (f.coefficient.size() == N(0)) {
    return out << "[ 0 ]";
  }

  if (f.negative) {
    out << "- ";
  }
  out << "[";
  for (N i = N(0); i < f.coefficient.size(); i++) {
    if (i == N(0)) {
      out << " " << f.coefficient[i];
    } else if (i == N(1)) {
      out << "; " << f.coefficient[i];
    } else {
      out << ", " << f.coefficient[i];
    }
  }

  return out << " ]";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x54f6
movq %rsi, %r14
cmpb $0x1, 0x18(%rsi)
jne 0x5468
leaq 0xdcc3(%rip), %rsi      # 0x13123
movq %rbx, %rdi
callq 0x4270
leaq 0xe66d(%rip), %rsi      # 0x13adc
movq %rbx, %rdi
callq 0x4270
xorl %r15d, %r15d
leaq 0xe604(%rip), %r13      # 0x13a85
leaq 0xe659(%rip), %rbp      # 0x13ae1
xorl %r12d, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0x54ed
movq %rbx, %rdi
cmpq $0x1, %r12
je 0x54b6
testq %r12, %r12
jne 0x54cb
movq %r13, %rsi
callq 0x4270
movq (%r14), %rcx
jmp 0x54d9
leaq 0xe621(%rip), %rsi      # 0x13ade
callq 0x4270
movq (%r14), %rcx
addq $0x8, %rcx
jmp 0x54d9
movq %rbp, %rsi
callq 0x4270
movq (%r14), %rcx
addq %r15, %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x40b0
incq %r12
addq $0x8, %r15
jmp 0x548b
leaq 0xe5e5(%rip), %rsi      # 0x13ad9
jmp 0x54fd
leaq 0xe5d9(%rip), %rsi      # 0x13ad6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4270
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/fractions.h
// Function: efgy::math::numeric::fractional<long long>::operator*=(long long const&)
fractional &operator*=(const N &b) {
    numerator *= b;
    normalise();
    // minimise();
    return (*this);
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
imulq (%rsi), %rax
movq %rax, (%rdi)
callq 0x11e80
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/continued-fractions.h
// Function: efgy::math::numeric::continuedFractional<long long>::operator,(long long const&) const
continuedFractional operator,(const N &pB) const {
    continuedFractional rv = *this;
    N b = pB;
    if (b < zero()) {
      rv.negative = true;
      rv.coefficient.push_back(-b);
    } else {
      rv.coefficient.push_back(b);
    }
    return rv;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x12872
movq (%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
js 0x1283a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11f0a
jmp 0x12851
movb $0x1, 0x18(%rbx)
negq %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x1285e
movq %rax, %r14
movq %rbx, %rdi
callq 0xf4b8
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/writedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<4) { 
    usage();
    exit(-1);
  }
  SIZE_T blocknum=atoi(argv[2]);
  SIZE_T numblocks=atoi(argv[3]);
  double reqtime;

  DiskSystem disk(argv[1]);
  SIZE_T blocksize = disk.GetBlockSize();

  vector<Block> b;

  for (unsigned i=0;i<numblocks;i++) { 
    Block block(blocksize);
    for (unsigned j=0;j<blocksize;j++) { 
      cin >> block.data[j];
    }
    b.push_back(block);
  }


  ERROR_T rc= disk.Write(blocknum, numblocks, b, reqtime);

  if (rc!=ERROR_NOERROR) { 
    cerr << "Error "<< rc << " occured.\n";
    return -1;
  } else {
    cerr << "Your data was successfully written.\n";
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
cmpl $0x3, %edi
jle 0x268a
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x22c0
movl %eax, 0x1c(%rsp)
movq 0x18(%r14), %rdi
callq 0x22c0
movl %eax, 0x18(%rsp)
movq 0x8(%r14), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x26e2
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2de0
leaq 0x38(%rsp), %rdi
callq 0x20a0
leaq 0x68(%rsp), %rdi
callq 0x3cac
movl %eax, %r14d
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movl %r14d, %ebx
xorl %r15d, %r15d
leaq 0x38(%rsp), %r12
movq 0x5a26(%rip), %r13      # 0x7fd8
cmpl 0x18(%rsp), %r15d
je 0x25fa
movq %r12, %rdi
movl %r14d, %esi
callq 0x2abe
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x25e0
movq 0x40(%rsp), %rsi
addq %rbp, %rsi
movq %r13, %rdi
callq 0x2240
incq %rbp
jmp 0x25c6
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x271e
movq %r12, %rdi
callq 0x2c42
incl %r15d
jmp 0x25b2
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rcx
leaq 0x60(%rsp), %r8
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x3af0
movl %eax, %ebx
testl %eax, %eax
je 0x264d
movq 0x59cd(%rip), %rdi      # 0x7ff0
leaq 0x2a0f(%rip), %rsi      # 0x5039
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x2320
leaq 0x2a00(%rip), %rsi      # 0x5040
movq %rax, %rdi
callq 0x2170
pushq $-0x1
popq %rbx
jmp 0x2662
xorl %ebx, %ebx
movq 0x599a(%rip), %rdi      # 0x7ff0
leaq 0x29ee(%rip), %rsi      # 0x504b
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x274a
leaq 0x68(%rsp), %rdi
callq 0x31ee
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24ec
pushq $-0x1
popq %rdi
callq 0x2210
movq %rax, %rbx
jmp 0x26d0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20a0
jmp 0x26da
movq %rax, %rbx
jmp 0x26da
jmp 0x26b4
jmp 0x26b9
movq %rax, %rbx
jmp 0x26c6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2c42
leaq 0x20(%rsp), %rdi
callq 0x274a
leaq 0x68(%rsp), %rdi
callq 0x31ee
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/main.cpp
// Function: main
int main(int argc, char *args[]) {
    if (argc != 2) {
        std::cout<<"code file not given"<<std::endl;
        return 0;
    }
    std::ifstream fin(args[1]);
    std::string str((std::istreambuf_iterator<char>(fin)), std::istreambuf_iterator<char>());

    Lexer lexer(str);
    lexer.lex();
    // lexer.debug();

    Parser parser(lexer.getTokens());
    parser.parse();
    // parser.debug();

    Assembler assembler(parser.getAsmCode());
    assembler.assemble();
    // assembler.debug();

    VirtualMachine vm(assembler.getBinCode());
    vm.execute();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
cmpl $0x2, %edi
jne 0x3724
movq 0x8(%rsi), %rsi
leaq -0x540(%rbp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3370
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq -0x458(%rbp,%rax), %rsi
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x28(%rbp), %rdi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x4c80
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x37c8
leaq -0x68(%rbp), %rdi
callq 0x5484
leaq -0x40(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x3fe8
leaq -0x240(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x37f0
leaq -0x188(%rbp), %rdi
callq 0x38ba
leaq -0x240(%rbp), %rdi
callq 0x7334
leaq -0x208(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x38e6
leaq -0x188(%rbp), %rdi
callq 0x8f7c
leaq -0x168(%rbp), %rsi
leaq -0x338(%rbp), %rdi
callq 0xa26c
leaq -0x338(%rbp), %rdi
callq 0xa4fc
leaq -0x338(%rbp), %rdi
callq 0x3eae
leaq -0x188(%rbp), %rdi
callq 0x3ef0
leaq -0x240(%rbp), %rdi
callq 0x3f46
leaq -0x68(%rbp), %rdi
callq 0x3fba
leaq -0x28(%rbp), %rdi
callq 0x33a8
leaq -0x540(%rbp), %rdi
callq 0x3090
jmp 0x373f
movq 0xe8a5(%rip), %rdi      # 0x11fd0
leaq 0x88d2(%rip), %rsi      # 0xc004
callq 0x31d0
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x338(%rbp), %rdi
callq 0x3eae
jmp 0x3761
jmp 0x375e
movq %rax, %rbx
leaq -0x188(%rbp), %rdi
callq 0x3ef0
jmp 0x3774
jmp 0x3771
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x3f46
jmp 0x3798
movq %rax, %rbx
leaq -0x188(%rbp), %rdi
callq 0x38ba
jmp 0x3798
jmp 0x3795
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3fba
leaq -0x28(%rbp), %rdi
callq 0x33a8
leaq -0x540(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3350
movq %rax, %rbx
jmp 0x37a1
movq %rax, %rbx
jmp 0x37aa
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: BlockAST::print()
void BlockAST::print() {
    std::cout<<"block: {"<<std::endl;
    for (auto it = statements.begin(); it != statements.end(); ++it) {
        (*it)->print();
    }
    std::cout<<"}"<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc86f(%rip), %rdi      # 0x11fd0
leaq 0x6a8c(%rip), %rsi      # 0xc1f4
callq 0x31d0
movq %rax, %rdi
callq 0x3110
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0x578e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
jmp 0x5779
movq 0xc83b(%rip), %rdi      # 0x11fd0
leaq 0x6a61(%rip), %rsi      # 0xc1fd
callq 0x31d0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: IfExprAST::print()
void IfExprAST::print() {
    std::cout<<"if\t";
    condAST->print();
    ifBlockAST->print();
    if (elseBlockAST) {
        std::cout<<"else\t";
        elseBlockAST->print();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc812(%rip), %rdi      # 0x11fd0
leaq 0x6a3a(%rip), %rsi      # 0xc1ff
callq 0x31d0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x20(%rbx)
je 0x5808
movq 0xc7e4(%rip), %rdi      # 0x11fd0
leaq 0x6a10(%rip), %rsi      # 0xc203
callq 0x31d0
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: CallFuncAST::print()
void CallFuncAST::print() {
    std::cout<<"call func: "<<mCallee<<"("<<std::endl;
    for (auto it = mArgs.begin(); it != mArgs.end(); ++it) {
        (*it)->print();
    }
    std::cout<<")"<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc779(%rip), %rdi      # 0x11fd0
leaq 0x69b2(%rip), %rsi      # 0xc210
callq 0x31d0
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x69b2(%rip), %rsi      # 0xc228
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3110
movq 0x30(%rbx), %r14
cmpq 0x38(%rbx), %r14
je 0x589f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
jmp 0x588a
movq 0xc72a(%rip), %rdi      # 0x11fd0
leaq 0x6a39(%rip), %rsi      # 0xc2e6
callq 0x31d0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: FunctionAST::print()
void FunctionAST::print() {
    std::cout<<"def func "<<mFunc.second<<": (";
    for (auto it = mArgs.begin(); it != mArgs.end(); ++it) {
        std::cout<<(*it).second<<", ";
    }
    std::cout<<"nullptr) ";
    blockAST->print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xc6fd(%rip), %r14      # 0x11fd0
leaq 0x6942(%rip), %rsi      # 0xc21c
movq %r14, %rdi
callq 0x31d0
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x6931(%rip), %rsi      # 0xc226
movq %rax, %rdi
callq 0x31d0
movq 0x38(%rbx), %r12
leaq 0x6922(%rip), %r15      # 0xc22a
cmpq 0x40(%rbx), %r12
je 0x592c
leaq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x31b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
addq $0x28, %r12
jmp 0x5908
movq 0xc69d(%rip), %rdi      # 0x11fd0
leaq 0x68f3(%rip), %rsi      # 0xc22d
callq 0x31d0
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: AssignmentAST::eval[abi:cxx11]()
std::string AssignmentAST::eval() {
    std::string str;
    for (auto it = mVarList.begin(); it != mVarList.end(); ++it) {
        str += "INT " + static_cast<VariableAST*>(static_cast<BinaryExprAST*>(*it)->getLNode())->getName()
         + insEnd + (*it)->eval();
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %r14
leaq -0x78(%rbp), %r12
leaq -0x98(%rbp), %r15
leaq -0x58(%rbp), %r13
leaq -0xb8(%rbp), %rbx
movq -0x38(%rbp), %rax
cmpq 0x18(%rax), %r14
je 0x5b01
movq (%r14), %rax
movq 0x10(%rax), %rdx
addq $0x10, %rdx
movq %r12, %rdi
leaq 0x67a8(%rip), %rsi      # 0xc243
callq 0x6e29
movq %r15, %rdi
movq %r12, %rsi
leaq 0xc74b(%rip), %rdx      # 0x121f8
callq 0x6e00
movq (%r14), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6e9f
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x33a8
movq %r13, %rdi
callq 0x33a8
movq %r15, %rdi
callq 0x33a8
movq %r12, %rdi
callq 0x33a8
addq $0x8, %r14
jmp 0x5a7c
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5b4a
movq %rax, %rbx
jmp 0x5b3e
movq %rax, %rbx
jmp 0x5b35
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x33a8
leaq -0x58(%rbp), %rdi
callq 0x33a8
leaq -0x98(%rbp), %rdi
callq 0x33a8
leaq -0x78(%rbp), %rdi
callq 0x33a8
jmp 0x5b58
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: BlockAST::eval[abi:cxx11]()
std::string BlockAST::eval() {
    std::string str;
    for (auto it = statements.begin(); it != statements.end(); ++it) {
        str += (*it)->eval();
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x10(%rsi), %r12
leaq -0x40(%rbp), %r15
cmpq 0x18(%r14), %r12
je 0x62f3
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3390
movq %r15, %rdi
callq 0x33a8
addq $0x8, %r12
jmp 0x62c7
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6314
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: IfExprAST::eval[abi:cxx11]()
std::string IfExprAST::eval() {
    std::string str = condAST->eval();
    std::string label = generateJmpLabel();
    str += "JZ " + label + insEnd;    // "JZ LABEL"
    str += ifBlockAST->eval() + label + ":" + insEnd;
    if (elseBlockAST) {
        str += elseBlockAST->eval();
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
callq *0x18(%rax)
leaq -0x70(%rbp), %rdi
callq 0x64dd
leaq 0x5f18(%rip), %rsi      # 0xc26a
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x6e29
leaq 0xbe92(%rip), %rdx      # 0x121f8
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6e00
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
leaq -0x30(%rbp), %rdi
callq 0x33a8
leaq -0x50(%rbp), %rdi
callq 0x33a8
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x90(%rbp), %rdi
callq *0x18(%rax)
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x6e00
leaq 0x5eae(%rip), %rdx      # 0xc26e
leaq -0x50(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6f10
leaq 0xbe21(%rip), %rdx      # 0x121f8
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6e00
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
leaq -0x30(%rbp), %rdi
callq 0x33a8
leaq -0x50(%rbp), %rdi
callq 0x33a8
leaq -0xb0(%rbp), %rdi
callq 0x33a8
leaq -0x90(%rbp), %rdi
callq 0x33a8
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x6442
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
leaq -0x30(%rbp), %rdi
callq 0x33a8
leaq -0x70(%rbp), %rdi
callq 0x33a8
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
jmp 0x64b5
jmp 0x64bc
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x33a8
jmp 0x6476
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x33a8
jmp 0x6484
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0x33a8
jmp 0x6495
movq %rax, %r14
leaq -0x90(%rbp), %rdi
jmp 0x64b5
jmp 0x64bc
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x33a8
jmp 0x64b1
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x33a8
jmp 0x64bf
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x3350
movq %rax, %r14
jmp 0x64c8
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/AST.cpp
// Function: CallFuncAST::eval[abi:cxx11]()
std::string CallFuncAST::eval() {
    std::string str;
    if (mCallee == "input") {   // system func "input(int)"
        str += "SCAN " + mArgs[0]->eval().substr(5);
    } else if (mCallee == "output") {   // system func "output(int)"
        str += mArgs[0]->eval() + "PRIT" + insEnd;
    } else {
        for (auto it = mArgs.begin(); it != mArgs.end(); ++it) {
            str += (*it)->eval();
        }
        str += "CALL " + mCallee + insEnd;
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x10(%rsi), %r14
leaq 0x597f(%rip), %rsi      # 0xc275
movq %r14, %rdi
callq 0x54a3
testb %al, %al
je 0x694e
movq 0x30(%r15), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x88(%rbp), %rdi
callq *0x18(%rax)
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3200
leaq 0x5948(%rip), %rsi      # 0xc27b
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x6f71
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
jmp 0x69ac
leaq 0x592c(%rip), %rsi      # 0xc281
movq %r14, %rdi
callq 0x54a3
testb %al, %al
je 0x69c7
movq 0x30(%r15), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x88(%rbp), %rdi
callq *0x18(%rax)
leaq 0x56a5(%rip), %rdx      # 0xc021
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6f10
leaq 0xb865(%rip), %rdx      # 0x121f8
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6e00
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
leaq -0x48(%rbp), %rdi
callq 0x33a8
leaq -0x68(%rbp), %rdi
callq 0x33a8
leaq -0x88(%rbp), %rdi
jmp 0x6a3b
movq 0x30(%r15), %r13
leaq -0x48(%rbp), %r12
cmpq 0x38(%r15), %r13
je 0x69fb
movq (%r13), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3390
movq %r12, %rdi
callq 0x33a8
addq $0x8, %r13
jmp 0x69cf
leaq 0x5886(%rip), %rsi      # 0xc288
leaq -0x68(%rbp), %rdi
movq %r14, %rdx
callq 0x6e29
leaq 0xb7e3(%rip), %rdx      # 0x121f8
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6e00
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
leaq -0x48(%rbp), %rdi
callq 0x33a8
leaq -0x68(%rbp), %rdi
callq 0x33a8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x33a8
jmp 0x6a63
movq %rax, %r14
leaq -0x68(%rbp), %rdi
jmp 0x6aa9
jmp 0x6a9d
jmp 0x6a73
jmp 0x6a81
jmp 0x6a8f
jmp 0x6a9d
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x33a8
jmp 0x6a84
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x33a8
jmp 0x6a92
movq %rax, %r14
leaq -0x88(%rbp), %rdi
jmp 0x6aa9
jmp 0x6a9d
movq %rax, %r14
jmp 0x6aae
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/./AST.h
// Function: IfExprAST::~IfExprAST()
~IfExprAST() {
        delete condAST;
        delete ifBlockAST;
        if (elseBlockAST) {
            delete elseBlockAST;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaae6(%rip), %rax      # 0x11c50
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x717c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x718b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x71a0
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parse()
bool Parser::parse() {
    getNextToken(); // start parsing
    ASTNode *newStat = nullptr;
    while (curToken.first != Token::END_OF_FILE) {
        newStat = this->parseStatement();
        if (newStat) {
            ASTList.push_back(newStat);
        }
    }
    for (auto it = ASTList.begin(); it != ASTList.end(); ++it) {
        #ifdef DEBUG
        std::string temp = (*it)->eval();
        std::cout<<temp<<"<<"<<std::endl;
        asmcode += temp;
        #else
        asmcode += (*it)->eval();
        #endif
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x7fbe
leaq -0x28(%rbp), %r14
andq $0x0, (%r14)
leaq 0x18(%rbx), %r15
cmpl $-0x1, 0x58(%rbx)
je 0x737b
movq %rbx, %rdi
callq 0x73d6
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x7357
movq %r15, %rdi
movq %r14, %rsi
callq 0x7fe4
jmp 0x7357
movq 0x18(%rbx), %r12
leaq 0x38(%rbx), %r14
leaq -0x48(%rbp), %r15
cmpq 0x20(%rbx), %r12
je 0x73b3
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3390
movq %r15, %rdi
callq 0x33a8
addq $0x8, %r12
jmp 0x7387
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseStatement()
ASTNode *Parser::parseStatement() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseStatement"<<std::endl;
    #endif
    switch (curToken.first) {
        case Token::KEYWORD_IF: {
            return this->parseIfExpr();
        }
        case Token::KEYWORD_WHILE: {
            return this->parseWhileExpr();
        }
        case Token::TYPE_INT: {
            return this->parseDeclaration();
        }
        case Token::KEYWORD_RET: {
            return this->parseFuncReturn();
        }
        default: {
            return this->parseExpression();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x58(%rdi), %eax
addl $-0x6, %eax
cmpl $0x4, %eax
ja 0x740d
leaq 0x4ea8(%rip), %rcx      # 0xc294
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbp
jmp 0x7414
popq %rbp
jmp 0x7528
popq %rbp
jmp 0x74b6
popq %rbp
jmp 0x7502
popq %rbp
jmp 0x75c8
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseIfExpr()
ASTNode *Parser::parseIfExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseIfExpr"<<std::endl;
    #endif
    getNextToken(); // eat "if"
    ASTNode *cond = this->parseParenExpr();
    ASTNode *ifblock = this->parseBlock();
    ASTNode *elseblock = nullptr;
    if (curToken.second == "else") {
        getNextToken(); // eat "else"
        if (curToken.second == "if") {  // "else if"
            elseblock = this->parseIfExpr();
        } else {
            elseblock = this->parseBlock();   // "else {}"
        }
    }
    ASTNode *ifExpr = new IfExprAST(cond, ifblock, elseblock);
    return ifExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
callq 0x7fbe
movq %r15, %rdi
callq 0x7966
movq %rax, %rbx
movq %r15, %rdi
callq 0x7ab8
movq %rax, %r14
leaq 0x60(%r15), %r12
leaq 0x4c9b(%rip), %rsi      # 0xc0e3
movq %r12, %rdi
callq 0x54a3
testb %al, %al
je 0x7479
movq %r15, %rdi
callq 0x7fbe
leaq 0x4c7d(%rip), %rsi      # 0xc0e0
movq %r12, %rdi
callq 0x54a3
movq %r15, %rdi
testb %al, %al
je 0x747e
callq 0x7414
jmp 0x7483
xorl %r15d, %r15d
jmp 0x7486
callq 0x7ab8
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x31e0
andl $0x0, 0x8(%rax)
leaq 0xa7a7(%rip), %rcx      # 0x11c40
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseWhileExpr()
ASTNode *Parser::parseWhileExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseWhileExpr"<<std::endl;
    #endif
    getNextToken(); // eat "while"
    ASTNode *cond = this->parseParenExpr();
    ASTNode *block = this->parseBlock();
    ASTNode *whileExpr = new WhileExprAST(cond, block);
    return whileExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x7fbe
movq %rbx, %rdi
callq 0x7966
movq %rax, %r14
movq %rbx, %rdi
callq 0x7ab8
movq %rax, %rbx
pushq $0x20
popq %rdi
callq 0x31e0
andl $0x0, 0x8(%rax)
leaq 0xa79a(%rip), %rcx      # 0x11c88
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseFuncReturn()
ASTNode *Parser::parseFuncReturn() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseFuncReturn"<<std::endl;
    #endif
    getNextToken(); // eat "return"
    ASTNode *retExpr = this->parseExpression();
    if (!retExpr) {
        retExpr = new NumberAST("0");
    }
    return new ReturnAST(retExpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x7fbe
movq %rbx, %rdi
callq 0x75c8
movq %rax, %rbx
testq %rax, %rax
jne 0x757f
pushq $0x30
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x4d59(%rip), %rsi      # 0xc2b6
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30d0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x8008
leaq -0x38(%rbp), %rdi
callq 0x33a8
pushq $0x18
popq %rdi
callq 0x31e0
andl $0x0, 0x8(%rax)
leaq 0xa786(%rip), %rcx      # 0x11d18
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x33a8
jmp 0x75b7
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseNumber()
ASTNode *Parser::parseNumber() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseNumber"<<std::endl;
    #endif
    // ASTNode *result = new NumberAST(strtod(curToken.second.c_str(), nullptr));
    ASTNode *result = new NumberAST(curToken.second);
    getNextToken();
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x60(%r14), %rsi
movq %rax, %rdi
callq 0x8008
movq %r14, %rdi
callq 0x7fbe
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseParenExpr()
ASTNode *Parser::parseParenExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseParenExpr"<<std::endl;
    #endif
    getNextToken();  // eat '('
    ASTNode *expr = this->parseExpression();
    if (curToken.first != static_cast<Token>(')')) {
        std::cout<<"expected \')\'"<<std::endl;
    }
    getNextToken();  // eat ')'
    return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x7fbe
movq %rbx, %rdi
callq 0x75c8
movq %rax, %r14
cmpl $0x29, 0x58(%rbx)
je 0x79a1
movq 0xa643(%rip), %rdi      # 0x11fd0
leaq 0x4915(%rip), %rsi      # 0xc2a9
callq 0x31d0
movq %rax, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x7fbe
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseIdentifier()
ASTNode *Parser::parseIdentifier() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseIdentifier"<<std::endl;
    #endif
    std::string identifier = curToken.second;
    getNextToken();
    // variable name
    if (curToken.first != static_cast<Token>('(')) {
        return new VariableAST(identifier);
    }
    // function call
    getNextToken(); // eat '('
    std::vector<ASTNode*> args;
    while (true) {
        ASTNode *arg = parseExpression();
        if (arg) {
            args.push_back(arg);
        }
        if (curToken.first == static_cast<Token>(')')) {
            getNextToken(); // eat ')'
            break;
        }
    }
    return new CallFuncAST(identifier, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x7fbe
cmpl $0x28, 0x58(%rbx)
jne 0x7a49
movq %rbx, %rdi
callq 0x7fbe
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x20(%rbp), %r15
movq %rbx, %rdi
callq 0x75c8
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x7a15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe4
cmpl $0x29, 0x58(%rbx)
jne 0x79f9
movq %rbx, %rdi
callq 0x7fbe
pushq $0x48
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rax, %rdi
callq 0x8048
leaq -0x40(%rbp), %rdi
callq 0x44ba
jmp 0x7a60
pushq $0x30
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x8028
leaq -0x60(%rbp), %rdi
callq 0x33a8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
jmp 0x7a9d
jmp 0x7a9a
jmp 0x7a9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
jmp 0x7aa6
movq %rax, %r14
jmp 0x7aa6
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x44ba
leaq -0x60(%rbp), %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseBlock()
ASTNode *Parser::parseBlock() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseBlock"<<std::endl;
    #endif
    getNextToken(); // eat '{'
    std::vector<ASTNode*> stats;
    while (curToken.first != static_cast<Token>('}')) {
        ASTNode *newStat = this->parseStatement();
        if (newStat) {
            stats.push_back(newStat);
        }
    }
    ASTNode *block = new BlockAST(stats);
    getNextToken(); // eat '}'
    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x7fbe
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x20(%rbp), %r15
cmpl $0x7d, 0x58(%rbx)
je 0x7b05
movq %rbx, %rdi
callq 0x73d6
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x7ae1
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe4
jmp 0x7ae1
pushq $0x28
popq %rdi
callq 0x31e0
movq %rax, %r14
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x810a
movq %rbx, %rdi
callq 0x7fbe
leaq -0x40(%rbp), %rdi
callq 0x44ba
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x7b4d
jmp 0x7b4a
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x44ba
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseFuncDeclaration()
ASTNode *Parser::parseFuncDeclaration() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseFuncDeclaration"<<std::endl;
    #endif
    Token type = curToken.first;
    getNextToken(); // eat function return value type
    std::string name = curToken.second;
    getNextToken(); // eat function name
    std::vector<std::pair<Token, std::string>> args;
    // if function has argument
    if (lookAheadToken(1).first != static_cast<Token>(')')) {
        do {
            getNextToken(); // eat '(' or ','
            Token varType = curToken.first;
            getNextToken(); // eat type name
            std::string varName = curToken.second;
            getNextToken(); // eat arg name
            args.push_back(std::make_pair(varType, varName));
        } while (curToken.first != static_cast<Token>(')'));
    }
    // else function has no argument
    else {
        getNextToken(); // eat '('
    }
    getNextToken(); // eat ')'
    ASTNode *block = this->parseBlock();
    return new FunctionAST(std::make_pair(type, name), args, block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movl 0x58(%rdi), %r15d
callq 0x7fbe
leaq 0x60(%rbx), %r14
leaq -0x98(%rbp), %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x7fbe
movl %r15d, -0x2c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movslq 0x80(%rbx), %rax
movq (%rbx), %rcx
imulq $0x28, %rax, %rax
cmpl $0x29, (%rcx,%rax)
jne 0x7bc7
movq %rbx, %rdi
callq 0x7fbe
jmp 0x7c2b
leaq -0x70(%rbp), %r15
leaq -0xb8(%rbp), %r12
movq %rbx, %rdi
callq 0x7fbe
movl 0x58(%rbx), %r13d
movq %rbx, %rdi
callq 0x7fbe
movq %r12, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x7fbe
movl %r13d, -0x78(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3290
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x54d8
movq %r15, %rdi
callq 0x33a8
movq %r12, %rdi
callq 0x33a8
cmpl $0x29, 0x58(%rbx)
jne 0x7bd2
movq %rbx, %rdi
callq 0x7fbe
movq %rbx, %rdi
callq 0x7ab8
movq %rax, %rbx
pushq $0x58
popq %rdi
callq 0x31e0
movq %rax, %r14
leaq -0x70(%rbp), %r15
movl -0x2c(%rbp), %eax
movl %eax, -0x8(%r15)
leaq -0x98(%rbp), %rsi
movq %r15, %rdi
callq 0x3290
leaq -0x78(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x8150
movq %r15, %rdi
callq 0x33a8
leaq -0x50(%rbp), %rdi
callq 0x38ba
leaq -0x98(%rbp), %rdi
callq 0x33a8
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x33a8
jmp 0x7cb8
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x7cf2
movq %rax, %rbx
jmp 0x7cfb
jmp 0x7ccf
jmp 0x7ccf
jmp 0x7ccf
jmp 0x7ccf
movq %rax, %rbx
jmp 0x7cf2
jmp 0x7cd6
movq %rax, %rbx
jmp 0x7ce6
movq %rax, %rbx
movq %r15, %rdi
callq 0x33a8
leaq -0xb8(%rbp), %rdi
callq 0x33a8
leaq -0x50(%rbp), %rdi
callq 0x38ba
leaq -0x98(%rbp), %rdi
callq 0x33a8
movq %rbx, %rdi
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Assembler.cpp
// Function: Assembler::assemble()
bool Assembler::assemble() {
    this->init();
    this->redirect();
    this->interpret();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8fa4
movq %rbx, %rdi
callq 0x93dc
movq %rbx, %rdi
callq 0x964a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/Assembler.cpp
// Function: Assembler::interpret()
bool Assembler::interpret() {
    std::ostringstream oss;
    for (auto it = this->instructions.begin(); it != this->instructions.end(); ++it) {
        oss<<static_cast<int>(it->op)<<" ";
        for (int i = 0; i != it->args.size(); ++i) {
            oss<<it->args[i]<<" ";
        }
    }
    this->binCode = oss.str();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x3280
movq %rbx, -0x30(%rbp)
movq 0x70(%rbx), %r12
leaq 0x2bb6(%rip), %r15      # 0xc235
movq -0x30(%rbp), %rax
cmpq 0x78(%rax), %r12
je 0x96e1
movl 0x20(%r12), %esi
movq %r14, %rdi
callq 0x3340
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbx
je 0x96db
addq %r13, %rsi
movq %r14, %rdi
callq 0x31b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
incq %rbx
addq $0x20, %r13
jmp 0x96a6
addq $0x40, %r12
jmp 0x967f
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x32e0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %r14
movq %r14, %rsi
callq 0x3230
movq %r14, %rdi
callq 0x33a8
leaq -0x1c8(%rbp), %rdi
callq 0x3070
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9731
jmp 0x9731
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::VirtualMachine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
VirtualMachine::VirtualMachine(const std::string &code) {
    std::istringstream iss(code);
    int num = 0;
    while (iss>>num) {
        this->binCode.push_back(num);
    }
    int *global = new int[DATA_SEG_SIZE];
    this->data.push_back(global);
    bool *globalFlag = new bool[DATA_SEG_SIZE];
    memset(globalFlag, false, DATA_SEG_SIZE);
    this->dataFlag.push_back(globalFlag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x80c4
leaq 0x68(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x80(%rbx), %r12
leaq 0xa0(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
andl $0x0, 0x98(%rbx)
movq %r13, %rdi
movq %r15, -0x38(%rbp)
callq 0x80c4
leaq -0x1d0(%rbp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x3330
leaq -0x3c(%rbp), %r14
andl $0x0, (%r14)
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xa31f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad56
jmp 0xa2f9
movl $0x190, %edi            # imm = 0x190
callq 0x3030
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
movq -0x30(%rbp), %rdi
callq 0xad7c
pushq $0x64
popq %rdi
callq 0x3030
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andl $0x0, 0x60(%rax)
movq %r12, %rdi
callq 0xada0
leaq -0x1d0(%rbp), %rdi
callq 0x3100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xa3ae
movq %rax, %r14
jmp 0xa3b6
movq %rax, %r14
jmp 0xa3d0
jmp 0xa39f
jmp 0xa39f
movq %rax, %r14
leaq -0x1d0(%rbp), %rdi
callq 0x3100
movq %r13, %rdi
callq 0x4bee
movq %r12, %rdi
callq 0x4c44
movq -0x30(%rbp), %rdi
callq 0x4c58
movq -0x38(%rbp), %rdi
callq 0x4bee
movq %rbx, %rdi
callq 0x4c6c
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::printStack()
void VirtualMachine::printStack() {
    if (!this->stack.empty()) {
        std::cout<<"stack top: "<<this->stack.top()<<std::endl;
    } else {
        std::cout<<"stack top: none"<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
cmpq 0x28(%rdi), %rax
je 0xa42a
movq %rdi, %rbx
movq 0x7bd6(%rip), %rdi      # 0x11fd0
leaq 0x2003(%rip), %rsi      # 0xc404
callq 0x31d0
movq 0x48(%rbx), %rcx
cmpq 0x50(%rbx), %rcx
jne 0xa41d
movq 0x60(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movl -0x4(%rcx), %esi
movq %rax, %rdi
callq 0x3340
jmp 0xa43d
movq 0x7b9f(%rip), %rdi      # 0x11fd0
leaq 0x1fd8(%rip), %rsi      # 0xc410
callq 0x31d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O2/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::printData()
void VirtualMachine::printData() {
    for (int i = 0; i != eipStack.size()+1; ++i) {
        std::cout<<"data stack "<<i<<": ";
        for (int j = 0; j != 10; ++j) {
            std::cout<<data[i][j]<<" ";
        }
        std::cout<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
movq 0x7b5e(%rip), %r12      # 0x11fd0
leaq 0x1dbc(%rip), %r13      # 0xc235
movq -0x30(%rbp), %rdi
callq 0x8cea
incq %rax
cmpq %r15, %rax
je 0xa4ed
movq %r12, %rdi
leaq 0x1f8c(%rip), %rsi      # 0xc420
callq 0x31d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x3340
movq %rax, %rdi
leaq 0x1d6b(%rip), %rsi      # 0xc219
callq 0x31d0
xorl %r14d, %r14d
cmpq $0xa, %r14
je 0xa4e0
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r14,4), %esi
movq %r12, %rdi
callq 0x3340
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
incq %r14
jmp 0xa4b6
movq %r12, %rdi
callq 0x3110
incq %r15
jmp 0xa479
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/CTransR/Train_CTransR.cpp
// Function: Train::add(int, int, int)
void add(int x,int y,int z)
    {
        fb_h.push_back(x);
        fb_r.push_back(z);
        fb_l.push_back(y);
        ok[make_pair(x,z)][y]=1;
        ok_fb[make_pair(x,cluster2fb[z])][y]=1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x14(%rsp), %r15
movl %esi, (%r15)
leaq 0x10(%rsp), %rbx
movl %edx, (%rbx)
leaq 0xc(%rsp), %r12
movl %ecx, (%r12)
addq $0x90, %rdi
movq %r15, %rsi
callq 0x40b2
leaq 0xc0(%r14), %rdi
movq %r12, %rsi
callq 0x40b2
leaq 0xa8(%r14), %rdi
movq %rbx, %rsi
callq 0x40b2
movl (%r15), %eax
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rsp, %r13
movq %rcx, (%r13)
movq %r14, %rdi
movq %r13, %rsi
callq 0x40d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3736
pushq $0x1
popq %rbp
movl %ebp, (%rax)
addq $0x30, %r14
leaq 0x39721(%rip), %rdi     # 0x3cf50
movq %r12, %rsi
callq 0x3736
movl (%r15), %ecx
movl (%rax), %eax
shlq $0x20, %rax
orq %rcx, %rax
movq %rax, (%r13)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3736
movl %ebp, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq