LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/reedoo.cc
// Function: load_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string load_program(string filename) {

  string filedata;

    ifstream rdfile(filename,ios::binary);
    /* We check to see whether or not we can open the file. This doesn't tell use whether
       the file exists because permissions could also prevent us being able to open the file. */
    if (!rdfile) {
      cout << IO_ERROR << "Unable to open the file \"" << filename << "\"." << endl;
      exit(0);
    }
    /* Loop through and grab each line of the file, then store each line in filedata. */
    for (std::string line; std::getline(rdfile, line); )
    {
        filedata += line;
        filedata += "\n";
    }

    /* Close the file when we're done. */
    rdfile.close();

    /* Return the data so that the rest of the program can use it. */
    return filedata;                       
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x22f0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x2c7c
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
movq %rsp, %r15
leaq 0xb461(%rip), %r12      # 0xe04c
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq (%rsp), %rsi
jne 0x2c3b
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2350
jmp 0x2beb
cmpq %rbp, %rsi
je 0x2c53
movq 0x10(%rsp), %rax
incq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21e0
leaq 0x20(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe355(%rip), %rdi      # 0x10fd8
leaq 0xb399(%rip), %rsi      # 0xe023
movl $0xb, %edx
callq 0x2230
movq 0xe33d(%rip), %rdi      # 0x10fd8
leaq 0xb38d(%rip), %rsi      # 0xe02f
movl $0x19, %edx
callq 0x2230
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0xe31e(%rip), %rdi      # 0x10fd8
callq 0x2230
movq %rax, %r14
leaq 0xb380(%rip), %rsi      # 0xe049
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq %r14, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2250
movq %rax, %r14
jmp 0x2d12
movq %rax, %r14
jmp 0x2d08
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x20(%rsp), %rdi
callq 0x2090
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x2d26
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/reedoo.cc
// Function: main
int main(int argc, char* argv[]) {

   for(int i = 0; i < argc; i++) {
    string arg(argv[i]);
    
    if (arg == "-v") { // Example flag -v

    }

   }
   string arg(argv[1]);
  if (!argv[1]) {
   cout << "Usage: reedoo <filename> [args]" << endl;
  } else if (arg == "-v") {
   cout << "Reedoo v0.04 (pre-alpha)" << endl;
   cout << "The Reedoo Language Interpreter" << endl;
   cout << "(c) 2014 Francis McNamee. All Rights Reserved." << endl;
   cout << "www.reedoo.org" << endl;
   exit(0);
  } else {
   exec_program(argv[1]);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
testl %edi, %edi
jle 0x2ee2
movl %edi, %ebp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0xb1aa(%rip), %r12      # 0xe04e
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x30a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x20b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2eda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
incq %r13
cmpq %r13, %rbp
jne 0x2ea4
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30a0
cmpq $0x0, 0x8(%rbx)
je 0x2f4f
leaq 0xb14b(%rip), %rsi      # 0xe04e
leaq 0x8(%rsp), %rdi
callq 0x20b0
testl %eax, %eax
je 0x2fc1
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30a0
leaq 0x28(%rsp), %rdi
callq 0x2d2e
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f95
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2f95
movq 0xe082(%rip), %rbx      # 0x10fd8
leaq 0xb0f4(%rip), %rsi      # 0xe051
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0xe050(%rip), %rdi      # 0x10fd8
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fb0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe010(%rip), %rdi      # 0x10fd8
leaq 0xb0a2(%rip), %rsi      # 0xe071
movl $0x18, %edx
callq 0x2230
movq 0xdff8(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfec(%rip), %rdi      # 0x10fd8
leaq 0xb097(%rip), %rsi      # 0xe08a
movl $0x1f, %edx
callq 0x2230
movq 0xdfd4(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfc8(%rip), %rdi      # 0x10fd8
leaq 0xb093(%rip), %rsi      # 0xe0aa
movl $0x2e, %edx
callq 0x2230
movq 0xdfb0(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfa4(%rip), %rdi      # 0x10fd8
leaq 0xb09e(%rip), %rsi      # 0xe0d9
movl $0xe, %edx
callq 0x2230
movq 0xdf8c(%rip), %rdi      # 0x10fd8
callq 0x2100
xorl %edi, %edi
callq 0x2250
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x307d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x307d
jmp 0x307a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3098
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/variables.cc
// Function: goGETVAR(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string goGETVAR(string varname) {

  if (doVARLOOKUP(varname) == 0) {

    

    return variables[varname];

  } else {

    cout << IO_ERROR << "Variable not yet declared." << endl;
    exit(1);

  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x31d0
movq %r15, %rdi
callq 0xa8a2
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa811
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0xa84d
leaq 0x6d2c(%rip), %rdi      # 0x11548
movq %r14, %rsi
callq 0xaa04
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x31d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6784(%rip), %rdi      # 0x10fd8
leaq 0x37c8(%rip), %rsi      # 0xe023
callq 0x21c0
leaq 0x3b5c(%rip), %rsi      # 0xe3c3
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2100
movl $0x1, %edi
callq 0x2250
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa89a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/variables.cc
// Function: doVARLOOKUP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int doVARLOOKUP(string var) {

  if (variables[var] == "null") {
    return 2;
  } else if (variables[var] == "") {
    return 1;
  } else {
    return 0;
  }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6c9b(%rip), %rdi      # 0x11548
movq %rbx, %rsi
callq 0xaa04
leaq 0x3b27(%rip), %rsi      # 0xe3e3
movq %rax, %rdi
callq 0x20b0
testl %eax, %eax
je 0xa8f1
leaq 0x6c79(%rip), %rdi      # 0x11548
movq %rbx, %rsi
callq 0xaa04
leaq 0x389b(%rip), %rsi      # 0xe179
movq %rax, %rdi
callq 0x20b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0xa8f6
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/variables.cc
// Function: doASSIGN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void doASSIGN(string varname, string varval) {

  int vnl = 0;
  //cout << rdo_eval(varval.substr(5)) << endl;
  //varname = varname.substr(9);
  vnl = varname.length();
  if (varval.substr(0,4) == "expr") {
    varval = rdo_eval(varval.substr(5));
  }
  variables[varname] = varval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x4, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2200
leaq 0x3abb(%rip), %rsi      # 0xe3de
movq %r15, %rdi
callq 0x20b0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0xa947
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0xa9b0
leaq 0x20(%rsp), %r15
movl $0x5, %edx
movq %r15, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x2200
movq %rsp, %rdi
movq %r15, %rsi
callq 0xafc7
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xa995
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9b0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x6b91(%rip), %rdi      # 0x11548
movq %r14, %rsi
callq 0xaa04
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9f5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/eval.cc
// Function: rdo_opp_to_string[abi:cxx11](char)
string rdo_opp_to_string(char opp) {

	string o = "";

	switch(opp) {
		case '+':
			o = "+";
			break;
		case '-':
			o = "-";
			break;
		case '/':
			o = "/";
			break;
		case '*':
			o = "*";
			break;
		case '(':
			o = "(";
			break;
		case ')':
			o = ")";
			break;
	}

	return o;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x32a5(%rip), %rdx      # 0xe179
movq %rdx, %rsi
callq 0x3260
addb $-0x28, %bpl
cmpb $0x8, %bpl
jae 0xaf16
movzbl %bpl, %eax
movl $0xaf, %ecx
btl %eax, %ecx
jae 0xaf16
leaq 0x3559(%rip), %rdx      # 0xe454
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
movq 0x8(%rbx), %rdx
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x22d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xaf3a
movq (%r15), %rsi
incq %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/reedoolang[P]reedoo/eval.cc
// Function: rdo_is_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool rdo_is_num(string is_num) {
	if (is_num == "+" or
		is_num == "-" or
		is_num == "/" or
		is_num == "*" or
		is_num == "(" or
		is_num == ")") {
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x31ce(%rip), %rsi      # 0xe11b
callq 0x20b0
testl %eax, %eax
je 0xafb8
leaq 0x31c0(%rip), %rsi      # 0xe11d
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xafb8
leaq 0x31af(%rip), %rsi      # 0xe11f
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xafb8
leaq 0x319e(%rip), %rsi      # 0xe121
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xafb8
leaq 0x31dc(%rip), %rsi      # 0xe172
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xafb8
leaq 0x30df(%rip), %rsi      # 0xe088
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
setne %al
jmp 0xafba
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: BitRange(long, long)
Bitset BitRange(int64_t bit1, int64_t bit2)
{
    Bitset ret;
    ret.val = 0;
    for (; bit1 <= bit2; ++bit1)
        ret = ret + Bits(bit1);
    return ret;
}

// Assembly:
cmpq %rsi, %rdi
jle 0x3bbc
xorl %eax, %eax
retq
incq %rsi
movl $0x2f, %ecx
subq %rdi, %rcx
xorl %eax, %eax
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
movl $0x1, %edi
shlq %cl, %rdi
andq %rdx, %rdi
orq %rdi, %rax
leaq (%rsi,%rcx), %rdi
decq %rdi
decq %rcx
cmpq $0x2f, %rdi
jne 0x3bd3
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: Integer::operator=(long)
int64_t Integer::operator=(int64_t i)
{
    val = i;
    if (exp != 0 && exp != 127 && exp != 104)
        fprintf(stderr, "Data corruption!\n");
    exp = 104;
    return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
shlq $0x30, %rax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rcx
orq %rax, %rcx
movq %rcx, (%rdi)
movq %rsi, %rax
shrq $0x29, %rax
andl $0x7f, %eax
je 0x3c2d
cmpl $0x68, %eax
je 0x3c2d
cmpl $0x7f, %eax
jne 0x3c55
movabsq $-0xfe0000000001, %rax  # imm = 0xFFFF01FFFFFFFFFF
andq (%r14), %rax
movabsq $0xd00000000000, %rcx   # imm = 0xD00000000000
orq %rax, %rcx
movq %rcx, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3517
jmp 0x3c2d
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: besm6_alloc(unsigned long)
void * besm6_alloc(size_t s)
{
    s = (s + 7) & ~7;
    s /= sizeof(int64_t);
    if (avail + s > 32768) {
        fprintf(stderr, "Out of memory: avail = %ld, wants %lu words\n", avail, s);
        throw std::bad_alloc();
    }
    avail += s;
    return heap + avail - s;
}

// Assembly:
movq %rdi, %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
movq 0x2056b(%rip), %rdi     # 0x24280
leaq (%rdi,%rsi), %rax
cmpq $0x8001, %rax           # imm = 0x8001
jae 0x3d34
movq %rax, 0x20558(%rip)     # 0x24280
leaq 0x20aa1(%rip), %rax     # 0x247d0
leaq (%rax,%rdi,8), %rax
retq
pushq %rax
callq 0x3533
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: ptr(long)
void * ptr(int64_t x)
{
    if (x == 074000) return NULL;
    if (x < 0 || x >= avail) {
        fprintf(stderr, "Cannot convert %ld to a pointer, avail = %ld\n", x, avail);
        exit(1);
    }
    return heap + x;
}

// Assembly:
cmpq $0x7800, %rdi           # imm = 0x7800
jne 0x3d77
xorl %eax, %eax
retq
movq 0x20502(%rip), %rsi     # 0x24280
testq %rdi, %rdi
js 0x3d94
cmpq %rdi, %rsi
jle 0x3d94
leaq 0x20a41(%rip), %rax     # 0x247d0
leaq (%rax,%rdi,8), %rax
retq
pushq %rax
callq 0x35b4
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: ord(void*)
int64_t ord(void * p)
{
    int64_t ret = reinterpret_cast<int64_t>(p);
    if (p == NULL) return 074000;
    if (ret < avail || ret <= 100) return ret;
    if (p < heap || p >= heap + avail) {
        fprintf(stderr, "Invalid pointer to integer conversion, %p is outside of valid heap range %p-%p\n",
                p, (void*)heap, (void*)(heap + avail));
        exit(1);
    }
    if (heap + (reinterpret_cast<int64_t*>(p) - heap) != p) {
        fprintf(stderr, "Unaligned pointer to integer conversion: %p\n", p);
        exit(1);
    }
    return reinterpret_cast<int64_t*>(p) - heap;
}

// Assembly:
testq %rdi, %rdi
je 0x3dd8
movq 0x204da(%rip), %rax     # 0x24280
cmpq %rdi, %rax
setg %cl
cmpq $0x65, %rdi
setl %dl
orb %cl, %dl
jne 0x3ddd
leaq 0x20a12(%rip), %rdx     # 0x247d0
movq %rdi, %rcx
leaq (%rdx,%rax,8), %rsi
subq %rdx, %rcx
jb 0x3de1
cmpq %rdi, %rsi
jbe 0x3de1
sarq $0x3, %rcx
movq %rcx, %rdi
jmp 0x3ddd
movl $0x7800, %edi           # imm = 0x7800
movq %rdi, %rax
retq
pushq %rax
callq 0x35db
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: Alfa::print[abi:cxx11]() const
std::string Alfa::print() const
{
    std::string ret;
    for (int i = 1; i <= 6; ++i)
        ret += (*this)[i];
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x28, %r15d
movabsq $0xffffffffffff, %r13   # imm = 0xFFFFFFFFFFFF
movq (%r14), %rax
andq %r13, %rax
movl %r15d, %ecx
shrq %cl, %rax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3200
addq $-0x8, %r15
cmpq $-0x8, %r15
jne 0x3e1a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3e5f
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: toAscii[abi:cxx11](long)
std::string toAscii(int64_t val)
{
    std::string ret;
    for (int i = 0; i < 8; ++i) {
        int c = (val >> (42-(i*6))) & 077;
        if (c == 0) ret += ' ';
        else if (020 <= c && c <= 031) ret += char(c-020+'0');
        else if (041 <= c && c <= 072) ret += char (c-041+'A');
        else if (c == 012) ret += '*';
        else if (c == 017) ret += '/';
        else ret += '?';
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x2a, %r15d
movl $0x2a, %ebp
movq %r14, %rax
movl %r15d, %ecx
sarq %cl, %rax
andl $0x3f, %eax
je 0x4fd5
leal -0x10(%rax), %ecx
cmpl $0x9, %ecx
ja 0x4fd9
orb $0x20, %al
jmp 0x4ffa
movb $0x20, %al
jmp 0x4ffa
leal -0x21(%rax), %ecx
cmpl $0x19, %ecx
ja 0x4fe5
addb $0x20, %al
jmp 0x4ffa
cmpl $0xf, %eax
setne %cl
shlb $0x4, %cl
orb $0x2f, %cl
cmpl $0xa, %eax
movzbl %cl, %eax
cmovel %ebp, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x3200
addq $-0x6, %r15
cmpq $-0x6, %r15
jne 0x4fbb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5032
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: escapeChar[abi:cxx11](int)
std::string escapeChar(int c) {
    std::string ret;
    if (c < 32 || c >= 127) {
        char * strp;
        if (0 <= asprintf(&strp, "_%03o", c)) {
            ret = strp;
            free(strp);
        } else perror("asprintf");
    } else
        ret = char(c);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leal -0x7f(%rdx), %eax
cmpl $-0x60, %eax
ja 0x50a5
leaq 0x17b64(%rip), %rsi     # 0x1cbcd
movq %rsp, %rdi
xorl %eax, %eax
callq 0x30b0
testl %eax, %eax
js 0x50c9
movq (%rsp), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x30f0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x3390
movq (%rsp), %rdi
callq 0x32e0
jmp 0x50ba
movsbl %dl, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3460
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17b03(%rip), %rdi     # 0x1cbd3
callq 0x31f0
jmp 0x50ba
jmp 0x50d9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x50f0
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: printErrMsg(long)
void printErrMsg(int64_t errNo)
{
    putchar(' ');
    if (errNo >= 200)
        printf("Internal error %ld", errNo);
    else {
        if (errNo > 88)
            printErrMsg(86);
        else if (errNo == 20)
            errNo = (SY == IDENT)*2 + 1;
        else if (16 <= errNo && errNo <= 18)
            printf("%ld ", int64_t(curToken.i));
        printf("%s ", pasmitxt(errNo));
        if (errNo == 17)
            printf("%ld", int97z);
        else if (errNo == 22)
            printf("%6s", stmtName.c_str());
    }
    if (errNo != 86 && errNo != 78 && errNo != 79)
        putchar('\n');
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3330
cmpq $0xc8, %rbx
jl 0x55af
leaq 0x17c91(%rip), %rdi     # 0x1d231
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
jmp 0x565f
cmpq $0x59, %rbx
jl 0x55c1
movl $0x56, %edi
callq 0x5582
jmp 0x5604
cmpq $0x14, %rbx
jne 0x55dd
xorl %eax, %eax
cmpl $0x0, 0x5f25c(%rip)     # 0x6482c
sete %al
leaq 0x1(,%rax,2), %rbx
jmp 0x5604
leaq -0x10(%rbx), %rax
cmpq $0x2, %rax
ja 0x5604
movq 0x5f44a(%rip), %rsi     # 0x64a38
shlq $0x17, %rsi
sarq $0x17, %rsi
leaq 0x17c47(%rip), %rdi     # 0x1d244
xorl %eax, %eax
callq 0x3030
movq %rbx, %rdi
callq 0x53bb
leaq 0x17c36(%rip), %rdi     # 0x1d249
movq %rax, %rsi
xorl %eax, %eax
callq 0x3030
cmpq $0x16, %rbx
je 0x5645
cmpq $0x11, %rbx
jne 0x565f
movq 0x5f348(%rip), %rsi     # 0x64978
leaq 0x17c09(%rip), %rdi     # 0x1d240
xorl %eax, %eax
callq 0x3030
movl $0x11, %ebx
jmp 0x565f
movq 0x5f2a4(%rip), %rsi     # 0x648f0
leaq 0x17bfa(%rip), %rdi     # 0x1d24d
xorl %eax, %eax
callq 0x3030
movl $0x16, %ebx
addq $-0x4e, %rbx
cmpq $0x8, %rbx
ja 0x5676
movl $0x103, %eax            # imm = 0x103
btq %rbx, %rax
jae 0x5676
popq %rbx
retq
movl $0xa, %edi
popq %rbx
jmp 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: printTextWord(long)
void printTextWord(int64_t val)
{
    std::string str = toAscii(val);
    const char *s = str.c_str();
    while (*s == ' ')
        s++;
    fputs(s, stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4f8f
movq (%rbx), %rdi
decq %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x569a
movq 0x1e8dd(%rip), %rax     # 0x23f88
movq (%rax), %rsi
callq 0x32b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: toText(char const*)
int64_t toText(const char * str) {
    int64_t ret;
    ret = 0;
    for (; *str; ++str)
        ret = ret << 6 | koi2text[*str & 0xFF];
    return ret;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x56ff
incq %rdi
xorl %eax, %eax
leaq 0xb7b5a(%rip), %rdx     # 0xbd240
shlq $0x6, %rax
movzbl %cl, %ecx
movsbq (%rcx,%rdx), %rcx
orq %rcx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x56e6
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: makeStringType()
TypesPtr makeStringType()
{
    if (maxSmallString >= strLen)
        return smallStringType[strLen];
    else {
        RangeT * span = new RangeT;
        ArrayT * res = new ArrayT(0, 0, CharType);

        span->size = 1;
        span->checker = 0;
        span->bits = 12;
        span->base = IntegerType;
        span->left = 1;
        span->right = strLen;

        res->size = (strLen + 5) / 6;
        if (res->size == 1)
            res->bits = strLen * 8;
        else
            res->bits = 0;
        res->base = CharType;
        res->range = span;
        res->pck = true;
        res->perWord = 6;
        res->pcksize = 8;
        return res;
    }
}

// Assembly:
movq 0x5f1c7(%rip), %rax     # 0x648d0
cmpq %rax, 0x5f3c0(%rip)     # 0x64ad0
jge 0x57ec
pushq %r14
pushq %rbx
pushq %rax
movl $0x38, %edi
callq 0x3d03
movq %rax, %rbx
movl $0x1, %r14d
movq %r14, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
movl $0x40, %edi
callq 0x3d03
movq %rax, %rcx
movq 0x5f2b5(%rip), %rsi     # 0x64a08
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x5, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq %r14, (%rbx)
xorl %edi, %edi
movq %rdi, 0x20(%rbx)
movq $0xc, 0x8(%rbx)
movq 0x5f27c(%rip), %rax     # 0x649f8
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x5f145(%rip), %r8      # 0x648d0
movq %r8, 0x30(%rbx)
leaq 0x5(%r8), %rax
movabsq $0x2aaaaaaaaaaaaaab, %rdx # imm = 0x2AAAAAAAAAAAAAAB
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
addq %rdx, %rax
movq %rax, (%rcx)
decq %r8
movq 0x5f119(%rip), %rax     # 0x648d0
shlq $0x3, %rax
cmpq $0x6, %r8
cmovaeq %rdi, %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
movb $0x1, 0x28(%rcx)
movq $0x6, 0x30(%rcx)
movq $0x8, 0x38(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57f7
leaq 0x5f2ed(%rip), %rcx     # 0x64ae0
movq (%rcx,%rax,8), %rcx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: storeObjWord(long)
void storeObjWord(int64_t insn)
{
    objBuffer[objBufIdx] = insn;
    moduleOffset = moduleOffset + 1;
    if (objBufIdx == OBJBUF_SIZE) {
        error(49); /* errTooManyInsnsInBlock */
        objBufIdx = 1;
    } else
        objBufIdx = objBufIdx + 1;
}

// Assembly:
movq 0x5f0e5(%rip), %rax     # 0x64948
leaq 0xa79c6(%rip), %rcx     # 0xad230
movq %rdi, (%rcx,%rax,8)
incq 0x5f023(%rip)           # 0x64898
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x5893
pushq %rax
movl $0x31, %edi
callq 0x589e
movl $0x1, %eax
addq $0x8, %rsp
jmp 0x5896
incq %rax
movq %rax, 0x5f0ab(%rip)     # 0x64948
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: error(long)
void error(int64_t errNo)
{
    errors = true;
    bool110z = true;
    if (((linePos != prevErrPos) and (9 >= errsInLine))
        or (errNo == 52)) {
        totalErrors = totalErrors + 1;
        errMapBase[errsInLine] = linePos;
        errsInLine = errsInLine + 1;
        prevErrPos = linePos;
        printf("Error %ld:", errNo);
        printErrMsg(errNo);
        if (60 < totalErrors) {
            putchar('\n');
            endOfLine();
            printErrMsg(53);
            skipToEnd();
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
movb %al, 0x5f0dc(%rip)      # 0x64986
movb %al, 0x5f0dd(%rip)      # 0x6498d
movq 0x5efc9(%rip), %rax     # 0x64880
cmpq 0x5efca(%rip), %rax     # 0x64888
setne %dl
movq 0x5efc8(%rip), %rcx     # 0x64890
cmpq $0xa, %rcx
setl %sil
cmpq $0x34, %rdi
je 0x58db
andb %sil, %dl
je 0x5921
incq 0x5efd6(%rip)           # 0x648b8
leaq 0x63ca7(%rip), %rdx     # 0x69590
movq %rax, (%rdx,%rcx,8)
incq %rcx
movq %rcx, 0x5ef99(%rip)     # 0x64890
movq %rax, 0x5ef8a(%rip)     # 0x64888
leaq 0x17996(%rip), %rdi     # 0x1d29b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
movq %rbx, %rdi
callq 0x5582
cmpq $0x3d, 0x5ef99(%rip)    # 0x648b8
jge 0x5923
popq %rbx
retq
movl $0xa, %edi
callq 0x3330
callq 0x64c3
movl $0x35, %edi
callq 0x5582
callq 0x7f06
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: form1Insn(long)
void form1Insn(int64_t arg)
{
    Word Insn, opcode;
    int64_t pos;
    Insn.i = arg;
    opcode.i = Insn.i & ~077777;
    if (opcode.i == InsnTemp[UJ]) {
        if (prevOpcode == opcode.i)
            // No need for a jump after jump.
            return;
        if (putLeft and (prevOpcode == 1)) {
            pos = objBufIdx - 1;
            if (((objBuffer[pos] >> 24) & ~077777) == I13+KVJM) {
                // Chaining the call and the jump.
                int64_t addr1, addr2;
                prevOpcode = opcode.i;
                addr1 = Insn.ii & 077777;
                addr2 = (objBuffer[pos] >> 24) & 077777;
                objBuffer[pos] = (I13+KVTM+addr1) << 24 | (KUJ+addr2);
                return;
            }
        }
    };
    prevOpcode = opcode.i;
    if (putLeft) {
        leftInsn = Insn.ii << 24;
        putLeft = false;
    } else {
        putLeft = true;
        storeObjWord(leftInsn | (Insn.ii & halfWord));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3bf2
movq (%rbx), %rbx
movq %rbx, %rsi
shlq $0x17, %rsi
sarq $0x17, %rsi
andq $-0x8000, %rsi          # imm = 0x8000
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3bf2
movq (%r14), %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq 0x63b5c(%rip), %rax     # 0x694e8
jne 0x5a00
movq 0x5efd3(%rip), %rcx     # 0x64968
cmpq %rax, %rcx
je 0x5a22
cmpq $0x1, %rcx
jne 0x5a00
cmpb $0x0, 0x5efd9(%rip)     # 0x64984
je 0x5a00
movq 0x5ef94(%rip), %rcx     # 0x64948
leaq 0xa7875(%rip), %rdx     # 0xad230
movq -0x8(%rdx,%rcx,8), %rsi
movq %rsi, %rdi
shrq $0x27, %rdi
cmpl $0x1b9, %edi            # imm = 0x1B9
jne 0x5a00
movq %rax, 0x5ef92(%rip)     # 0x64968
shrq $0x18, %rsi
movl $0x7fff, %eax           # imm = 0x7FFF
andq %rax, %rsi
andq %rax, %rbx
shlq $0x18, %rbx
orq %rsi, %rbx
movabsq $0xda00000c0000, %rax   # imm = 0xDA00000C0000
orq %rbx, %rax
movq %rax, -0x8(%rdx,%rcx,8)
jmp 0x5a22
movq %rax, 0x5ef61(%rip)     # 0x64968
cmpb $0x1, 0x5ef76(%rip)     # 0x64984
jne 0x5a2a
shlq $0x18, %rbx
movq %rbx, 0x5f02d(%rip)     # 0x64a48
movb $0x0, 0x5ef62(%rip)     # 0x64984
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x5ef53(%rip)     # 0x64984
andl $0xffffff, %ebx         # imm = 0xFFFFFF
orq 0x5f00a(%rip), %rbx     # 0x64a48
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x585c
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: formJump(long&)
void formJump(int64_t & arg)
{
    int64_t pos;
    bool isLeft;
    if (prevOpcode != InsnTemp[UJ]) {
        pos = getObjBufIdxPlus();
        isLeft = putLeft;
        form1Insn(jumpType + arg);
        if (putLeft == isLeft)
            pos = pos - 1;
        arg = pos;
    }
}

// Assembly:
movq 0x5ee9b(%rip), %rax     # 0x64968
cmpq 0x63a14(%rip), %rax     # 0x694e8
je 0x5b1e
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x5eea0(%rip), %bpl     # 0x64984
movq 0x5ee5d(%rip), %rax     # 0x64948
leaq 0x1000(%rax), %r14
testb %bpl, %bpl
cmoveq %rax, %r14
movq (%rdi), %rdi
addq 0x5ed0d(%rip), %rdi     # 0x64810
callq 0x5941
xorl %eax, %eax
cmpb %bpl, 0x5ee73(%rip)     # 0x64984
sete %al
subq %rax, %r14
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: putToSymTab(long)
void putToSymTab(int64_t arg)
{
    symTab[symTabPos] = arg;
    if (symTabPos == SYMTAB_LIMIT) {
        error(50); /* errSymbolTableOverflow */
        symTabPos = 074000;
    } else
        symTabPos = symTabPos + 1;
}

// Assembly:
movq 0x5ecd4(%rip), %rax     # 0x64848
leaq 0x65185(%rip), %rcx     # 0x6ad00
movq %rdi, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x5b9d
pushq %rax
movl $0x32, %edi
callq 0x589e
movl $0x7800, %eax           # imm = 0x7800
addq $0x8, %rsp
jmp 0x5ba0
incq %rax
movq %rax, 0x5eca1(%rip)     # 0x64848
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: allocExtSymbol(long)
int64_t allocExtSymbol(int64_t newSym)
{
    int64_t ret = symTabPos;

    if (curVal.ii & halfWord) {
        int64_t i;
        for (i = 1; i <= longSymCnt; ++i) {
            if (curVal.ii == longSyms[i]) {
                return longSymTabBase[i];
            }
        }
        longSymCnt++;
        if (longSymCnt >= 90) {
            error(51); /* errLongSymbolOverflow */
            longSymCnt = 1;
        };
        longSymTabBase[longSymCnt] = symTabPos;
        longSyms[longSymCnt] = curVal.ii;
        newSym |= 020000000;
    } else {
        newSym |= curVal.ii;
    }
    putToSymTab(newSym);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x5ec92(%rip), %r14     # 0x64848
movq 0x5ee83(%rip), %rcx     # 0x64a40
testl $0xffffff, %ecx         # imm = 0xFFFFFF
je 0x5c1a
movq 0xa5134(%rip), %rax     # 0xaad00
testq %rax, %rax
setle %bpl
jle 0x5c22
movl $0x1, %edx
cmpq 0xa5417(%rip), %rcx     # 0xaaff8
je 0x5c0d
leaq -0x1(%rax), %rsi
xorl %edi, %edi
leaq 0xa5400(%rip), %r8      # 0xaaff0
cmpq %rdi, %rsi
je 0x5c1f
leaq 0x1(%rdi), %rdx
cmpq 0x10(%r8,%rdi,8), %rcx
movq %rdx, %rdi
jne 0x5bf0
cmpq %rax, %rdx
setge %bpl
incq %rdx
leaq 0xa50fc(%rip), %rax     # 0xaad10
movq (%rax,%rdx,8), %rax
jmp 0x5c7a
orq %rcx, %rbx
jmp 0x5c7f
movb $0x1, %bpl
leaq 0x1(%rax), %rcx
movq %rcx, 0xa50d3(%rip)     # 0xaad00
cmpq $0x59, %rax
jl 0x5c48
movl $0x33, %edi
callq 0x589e
movq $0x1, 0xa50b8(%rip) # 0xaad00
movq 0x5ebf9(%rip), %rax     # 0x64848
movq 0xa50aa(%rip), %rcx     # 0xaad00
leaq 0xa50b3(%rip), %rdx     # 0xaad10
movq %rax, (%rdx,%rcx,8)
movq 0x5edd8(%rip), %rax     # 0x64a40
leaq 0xa5381(%rip), %rdx     # 0xaaff0
movq %rax, (%rdx,%rcx,8)
orq $0x400000, %rbx         # imm = 0x400000
testb %bpl, %bpl
je 0x5cb7
movq 0x5ebc2(%rip), %rax     # 0x64848
leaq 0x65073(%rip), %rcx     # 0x6ad00
movq %rbx, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x5caa
movl $0x32, %edi
callq 0x589e
movl $0x7800, %eax           # imm = 0x7800
jmp 0x5cad
incq %rax
movq %rax, 0x5eb94(%rip)     # 0x64848
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: getHelperProc(long)
int64_t getHelperProc(int64_t l3arg1z)
{
    if (helperMap[l3arg1z] == 0)  {
        curVal.ii = helperNames[l3arg1z];
        helperMap[l3arg1z] = allocExtSymbol(extSymMask);
    };
    return helperMap[l3arg1z] + (KVJM+I13);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x64d16(%rip), %r14     # 0x6a9e0
cmpq $0x0, (%r14,%rdi,8)
jne 0x5cf1
leaq 0x1e6b8(%rip), %rax     # 0x24390
movq (%rax,%rbx,8), %rax
movq %rax, 0x5ed5d(%rip)     # 0x64a40
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5ba8
movq %rax, (%r14,%rbx,8)
movl $0xdc8000, %eax         # imm = 0xDC8000
addq (%r14,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: addCurValToFCST()
int64_t addCurValToFCST()
{
    int64_t ret;
    int64_t low, high, mid;
    low = 1;
    if (FcstTotal == 0) {
        ret = FcstCnt;
        FcstTotal = 1;
        constVals[1] = curVal;
        constNums[1] = FcstCnt;
        toFCST();
    } else {
        high = FcstTotal;
        do {
            mid = (low + high) / 2;
            if (curVal.m == constVals[mid].m) {
              return constNums[mid];
            }
            if (curVal.a < constVals[mid].a)
                high = mid - 1;
            else
                low = mid + 1;
        } while (low <= high);
        ret = FcstCnt;
        if (FcstTotal != MAXLIT) {
            if (curVal.a < constVals[mid].a)
                high = mid;
            else
                high = mid + 1;
            for (mid = FcstTotal; mid >= high; --mid) {
                low = mid + 1;
                constVals[low] = constVals[mid];
                constNums[low] = constNums[mid];
            }
            FcstTotal = FcstTotal + 1;
            constVals[high] = curVal;
            constNums[high] = FcstCnt;
        };
        toFCST();
    }
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x5ebec(%rip), %rax     # 0x64940
testq %rax, %rax
je 0x5e35
movabsq $0xffffffffffff, %rdi   # imm = 0xFFFFFFFFFFFF
movq 0x5ecd2(%rip), %rcx     # 0x64a40
movq %rcx, %r8
andq %rdi, %r8
movl $0x1, %r10d
leaq 0xa554f(%rip), %rdx     # 0xab2d0
movq %rax, %r9
leaq (%r9,%r10), %r11
movq %r11, %rsi
shrq $0x3f, %rsi
addq %r11, %rsi
sarq %rsi
movq (%rdx,%rsi,8), %rbx
movq %rcx, %r11
xorq %rbx, %r11
testq %rdi, %r11
je 0x5e63
notq %rbx
andq %rdi, %rbx
addq %r8, %rbx
movq %rbx, %r11
shrq $0x30, %r11
addq %rbx, %r11
leaq 0x1(%rsi), %r14
btq $0x2f, %r11
movq %r14, %rbx
jae 0x5dd0
leaq -0x1(%rsi), %r9
movq %r10, %rbx
movq %rbx, %r10
cmpq %r9, %rbx
jle 0x5d84
movq 0x5ea61(%rip), %rbx     # 0x64840
cmpq $0x1f4, %rax            # imm = 0x1F4
je 0x5e5c
btq $0x2f, %r11
cmovaeq %r14, %rsi
cmpq %rsi, %rax
jl 0x5e1a
leaq 0x1(%rax), %rdi
leaq 0xa6480(%rip), %r8      # 0xac280
movq -0x8(%rdx,%rdi,8), %r9
movq %r9, (%rdx,%rdi,8)
movq -0x8(%r8,%rdi,8), %r9
movq %r9, (%r8,%rdi,8)
decq %rdi
cmpq %rsi, %rdi
jg 0x5e00
incq %rax
movq %rax, 0x5eb1c(%rip)     # 0x64940
movq %rcx, (%rdx,%rsi,8)
leaq 0xa6451(%rip), %rax     # 0xac280
movq %rbx, (%rax,%rsi,8)
jmp 0x5e5c
movq 0x5ea04(%rip), %rbx     # 0x64840
movq $0x1, 0x5eaf9(%rip) # 0x64940
movq 0x5ebf2(%rip), %rax     # 0x64a40
movq %rax, 0xa5483(%rip)     # 0xab2d8
movq %rbx, 0xa642c(%rip)     # 0xac288
callq 0x5d02
jmp 0x5e6e
leaq 0xa6416(%rip), %rax     # 0xac280
movq (%rax,%rsi,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: allocSymtab(long)
int64_t allocSymtab(int64_t newSym)
{
    int64_t ret = symTabPos;

    if (symTabCnt == 0) {
        symTabCnt = 1;
        symTabArray[1] = newSym;
        symTabIndex[1] = symTabPos;
    } else {
        int64_t low = 1;
        int64_t high = symTabCnt;
        int64_t mid;

        do {
            mid = (low + high) / 2;
            if (newSym == symTabArray[mid]) {
                return symTabIndex[mid];
            }
            if (newSym < symTabArray[mid])
                high = mid - 1;
            else
                low = mid + 1;
        } while (high >= low);

        if (symTabCnt >= SYMTAB_MAX) {
            error(50); /* errSymbolTableOverflow */
        } else {
            if (newSym < symTabArray[mid])
                high = mid;
            else
                high = mid + 1;
            for (mid = symTabCnt; mid >= high; --mid) {
                low = mid + 1;
                symTabArray[low] = symTabArray[mid];
                symTabIndex[low] = symTabIndex[mid];
            }
            symTabCnt = symTabCnt + 1;
            symTabArray[high] = newSym;
            symTabIndex[high] = symTabPos;
        }
    }
    putToSymTab(newSym);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x5e9c0(%rip), %r14     # 0x64848
movq 0x5ec89(%rip), %rax     # 0x64b18
testq %rax, %rax
je 0x5ee8
movl $0x1, %edi
leaq 0x5ec80(%rip), %rcx     # 0x64b20
movq %rax, %r8
leaq (%r8,%rdi), %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
addq %rdx, %rsi
sarq %rsi
movq (%rcx,%rsi,8), %r15
cmpq %rbx, %r15
je 0x5f03
leaq 0x1(%rsi), %rdx
cmpq %rbx, %r15
jg 0x5ecb
movq %rdx, %rdi
jmp 0x5ecf
leaq -0x1(%rsi), %r8
cmpq %rdi, %r8
jge 0x5ea3
cmpq $0x3e8, %rax            # imm = 0x3E8
jl 0x5f10
movl $0x32, %edi
callq 0x589e
jmp 0x5f5a
movq $0x1, 0x5ec25(%rip) # 0x64b18
movq %rbx, 0x5ec2e(%rip)     # 0x64b28
movq %r14, 0x60b77(%rip)     # 0x66a78
jmp 0x5f5f
leaq 0x60b66(%rip), %rax     # 0x66a70
movq (%rax,%rsi,8), %rax
jmp 0x5f5a
cmpq %rbx, %r15
cmovgq %rsi, %rdx
cmpq %rdx, %rax
jl 0x5f41
leaq 0x1(%rax), %rsi
leaq 0x60b49(%rip), %rdi     # 0x66a70
movq -0x8(%rcx,%rsi,8), %r8
movq %r8, (%rcx,%rsi,8)
movq -0x8(%rdi,%rsi,8), %r8
movq %r8, (%rdi,%rsi,8)
decq %rsi
cmpq %rdx, %rsi
jg 0x5f27
incq %rax
movq %rax, 0x5ebcd(%rip)     # 0x64b18
movq %rbx, (%rcx,%rdx,8)
leaq 0x60b1a(%rip), %rax     # 0x66a70
movq %r14, (%rax,%rdx,8)
cmpq %rbx, %r15
je 0x5f97
movq 0x5e8e2(%rip), %rax     # 0x64848
leaq 0x64d93(%rip), %rcx     # 0x6ad00
movq %rbx, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x5f8a
movl $0x32, %edi
callq 0x589e
movl $0x7800, %eax           # imm = 0x7800
jmp 0x5f8d
incq %rax
movq %rax, 0x5e8b4(%rip)     # 0x64848
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: getFCSToffset()
int64_t getFCSToffset()
{
    int64_t ret;
    int64_t offset;
    ret = addCurValToFCST();
    offset = ret;
    if (offset < 2048) {
        /* empty */
    } else if (offset >= 4096)
        error(204);
    else {
        ret = allocSymtab(offset + 040000000) - 070000;
    }
    return ret;
}

// Assembly:
pushq %rbx
callq 0x5d49
movq %rax, %rbx
cmpq $0x800, %rax            # imm = 0x800
jl 0x5fdc
cmpq $0x1000, %rbx           # imm = 0x1000
jl 0x5fc3
movl $0xcc, %edi
callq 0x589e
jmp 0x5fdc
addq $0x800000, %rbx         # imm = 0x800000
movq %rbx, %rdi
callq 0x5e79
movq %rax, %rbx
addq $-0x7000, %rbx          # imm = 0x9000
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: card(Bitset)
int64_t card(Bitset b)
{
    int64_t val = b.val, ret = 0;
    while (val) {
        ++ret;
        val &= val-1;
    }
    return ret;
}

// Assembly:
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
xorl %eax, %eax
andq %rdi, %rcx
je 0x6034
incq %rax
leaq -0x1(%rcx), %rdx
andq %rdx, %rcx
jne 0x6028
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: nrOfBits(long)
int64_t minel(Bitset b)
{
    if (!b.val) return -1;
    int64_t ret = 0;
    uint64_t t = b.val;
    while (((t >> 47) & 1) == 0) {
        ret++;
        t <<= 1;
    }
    return ret;
}

// Assembly:
movq %rdi, %rax
shlq $0x10, %rax
je 0x6084
movabsq $0x7fffffffffff, %rcx   # imm = 0x7FFFFFFFFFFF
leaq 0x1(%rcx), %rdx
movl $0x30, %eax
testq %rdx, %rdi
je 0x608a
retq
movl $0x31, %eax
retq
andq %rcx, %rdi
bsrq %rdi, %rax
xorq $-0x40, %rax
addq $0x41, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: defineRange(Types*&, long, long)
void defineRange(TypesPtr & res, int64_t l, int64_t r)
{
    RangeT * temp = new RangeT;
    temp->base = res;
    temp->checker = 0;
    temp->left = l;
    temp->right = r;
    if (temp->left >= 0)
        temp->bits = nrOfBits(r);
    res = temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %edi
callq 0x3d03
movq $0x1, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
testq %r15, %r15
js 0x611f
movq %r14, %rcx
shlq $0x10, %rcx
je 0x6116
movabsq $0x7fffffffffff, %rdx   # imm = 0x7FFFFFFFFFFF
leaq 0x1(%rdx), %rsi
movl $0x30, %ecx
testq %rsi, %r14
jne 0x611b
andq %rdx, %r14
bsrq %r14, %rcx
xorq $-0x40, %rcx
addq $0x41, %rcx
jmp 0x611b
movl $0x31, %ecx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: getValueOrAllocSymtab(long)
int64_t getValueOrAllocSymtab(int64_t value)
{
    curVal.i = value;
    curVal.i = curVal.i & 077777;
    if (040000 >= curVal.i)
        return curVal.i;
    else
        return
            allocSymtab((curVal.ii | 040000000) & halfWord);
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
leaq 0x5e90d(%rip), %rbx     # 0x64a40
movq %rbx, %rdi
callq 0x3bf2
movq 0x5e8fe(%rip), %rsi     # 0x64a40
andl $0x7fff, %esi           # imm = 0x7FFF
movq %rbx, %rdi
callq 0x3bf2
movq 0x5e8e9(%rip), %rdi     # 0x64a40
movq %rdi, %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq $0x4001, %rax           # imm = 0x4001
jge 0x616c
popq %rbx
retq
andl $0x7fffff, %edi         # imm = 0x7FFFFF
orq $0x800000, %rdi         # imm = 0x800000
popq %rbx
jmp 0x5e79
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: OBPROG(long&, long&)
void OBPROG(int64_t & start, int64_t & fin)
{
    for (int64_t * p = &start; p <= &fin; ++p) {
        if (p != &start && (p - &start) % 4 == 0) putchar('\n');
        prInsn(*p >> 24); putchar(' '); prInsn(*p & 0xFFFFFF); printf("     ");
    }
    putchar('\n');
}

// Assembly:
cmpq %rsi, %rdi
ja 0x64b9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffff, %ebp         # imm = 0xFFFFFF
leaq 0x16e17(%rip), %r15     # 0x1d271
xorl %r12d, %r12d
testq %r12, %r12
je 0x6472
testb $0x18, %r12b
jne 0x6472
movl $0xa, %edi
callq 0x3330
leaq (%r14,%r12), %r13
addq $0x8, %r13
movl -0x5(%r13), %edi
callq 0x63e4
movl $0x20, %edi
callq 0x3330
movl -0x8(%r13), %edi
andl %ebp, %edi
callq 0x63e4
movq %r15, %rdi
xorl %eax, %eax
callq 0x3030
addq $0x8, %r12
cmpq %rbx, %r13
jbe 0x645d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %edi
jmp 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: readToPos80()
void readToPos80()
{
    while (!feof(pasinput) && linePos < 81 && PASINPUT != '\n') {
        linePos = linePos + 1;
        lineBufBase[linePos] = PASINPUT;
        if (linePos != 81) PASINPUT = ugetc(pasinput);
    }
    endOfLine();
}

// Assembly:
pushq %rbx
movq 0x1e01a(%rip), %rdi     # 0x247c0
callq 0x33a0
testl %eax, %eax
sete %dl
movq 0x5e0c9(%rip), %rax     # 0x64880
cmpq $0x51, %rax
setl %sil
movb 0x1e003(%rip), %cl      # 0x247c8
cmpb $0xa, %cl
setne %dil
andb %sil, %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x682e
leaq 0x62d21(%rip), %rbx     # 0x69500
leaq 0x1(%rax), %rdx
movq %rdx, 0x5e096(%rip)     # 0x64880
movb %cl, 0x1(%rax,%rbx)
cmpq $0x51, %rdx
je 0x6806
movq 0x1dfc5(%rip), %rdi     # 0x247c0
callq 0x6834
movb %al, 0x1dfc2(%rip)      # 0x247c8
movq 0x1dfb3(%rip), %rdi     # 0x247c0
callq 0x33a0
testl %eax, %eax
jne 0x682e
movq 0x5e063(%rip), %rax     # 0x64880
cmpq $0x50, %rax
jg 0x682e
movb 0x1df9f(%rip), %cl      # 0x247c8
cmpb $0xa, %cl
jne 0x67df
popq %rbx
jmp 0x64c3
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: nextCH()
void nextCH()
{
    do {
        atEOL = PASINPUT == '\n' || feof(pasinput);
        CH = PASINPUT;
        PASINPUT = ugetc(pasinput);
        linePos = linePos + 1;
        lineBufBase[linePos] = CH;
    } while (not ((maxLineLen >= linePos) or atEOL));
}

// Assembly:
pushq %rbx
leaq 0x62a9c(%rip), %rbx     # 0x69500
movb $0x1, %al
cmpb $0xa, 0x1dd5b(%rip)     # 0x247c8
je 0x6a80
movq 0x1dd4a(%rip), %rdi     # 0x247c0
callq 0x33a0
testl %eax, %eax
setne %al
movb %al, 0x5defb(%rip)      # 0x64981
movb 0x1dd3c(%rip), %al      # 0x247c8
movb %al, 0x5de97(%rip)      # 0x64929
movq 0x1dd27(%rip), %rdi     # 0x247c0
callq 0x6834
movb %al, 0x1dd24(%rip)      # 0x247c8
movq 0x5ddd5(%rip), %rax     # 0x64880
leaq 0x1(%rax), %rcx
movq %rcx, 0x5ddca(%rip)     # 0x64880
movb 0x5de6d(%rip), %cl      # 0x64929
movb %cl, 0x1(%rax,%rbx)
cmpq %rax, 0x5ddb1(%rip)     # 0x64878
jg 0x6ad2
testb $0x1, 0x5deb1(%rip)     # 0x64981
je 0x6a64
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: readOptVal(long)
int64_t readOptVal(int64_t limit)
{
    nextCH();
    int64_t res = 0;
    while (('9' >= CH) and (CH >= '0')) {
        res = 10 * res + CH - '0';
        nextCH();
        parseComment::super->badOpt = false;
    }
    if (limit < res) parseComment::super->badOpt = true;
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6a5c
movb 0x5de43(%rip), %al      # 0x64929
leal -0x30(%rax), %ecx
xorl %r14d, %r14d
cmpb $0x9, %cl
ja 0x6b1d
leaq (%r14,%r14,4), %rcx
movzbl %al, %eax
leaq (%rax,%rcx,2), %r14
addq $-0x30, %r14
callq 0x6a5c
movq 0xb689c(%rip), %rax     # 0xbd3a8
movb $0x0, (%rax)
movb 0x5de14(%rip), %al      # 0x64929
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x6af1
cmpq %rbx, %r14
jle 0x6b2c
movq 0xb687f(%rip), %rax     # 0xbd3a8
movb $0x1, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: readOptFlag(bool&)
void readOptFlag(bool & res)
{
    nextCH();
    if ((CH == '-') or (CH == '+')) {
        res = CH == '+';
        parseComment::super->badOpt = false;
    }
    nextCH();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6a5c
movzbl 0x5dde2(%rip), %eax     # 0x64929
cmpl $0x2d, %eax
je 0x6b51
cmpl $0x2b, %eax
jne 0x6b60
cmpb $0x2b, %al
sete (%rbx)
movq 0xb684b(%rip), %rax     # 0xbd3a8
movb $0x0, (%rax)
popq %rbx
jmp 0x6a5c
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: koi8_to_koi7(unsigned char)
unsigned char koi8_to_koi7(unsigned char ch)
{
    if (ch >= 0300)
        return (ch & 0177) | 040;
    if (ch >= 0200)
        return ' ';
    if (ch >= 0140)
        ch ^= 040;
    return ch;
}

// Assembly:
movl %edi, %eax
cmpb $-0x40, %al
jb 0x6e0e
andb $0x5f, %al
orb $0x20, %al
retq
testb %al, %al
js 0x6e23
movl %eax, %ecx
xorb $0x20, %cl
cmpb $0x60, %al
movzbl %al, %edx
movzbl %cl, %eax
cmovbl %edx, %eax
retq
movb $0x20, %al
retq