LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kage08[P]RegexLibrary/Resource.cpp
// Function: addConcat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::set<char, std::less<char>, std::allocator<char>>)
string addConcat(string& regex,set<char> alphabet){
  if(regex=="%") return regex;
  string ans="";
  uint len=regex.length();
  for(uLong i=0;i<len;i++){
    if(alphabet.find(regex[i])!=alphabet.end() || regex[i]=='@' || regex[i]=='(' || regex[i]=='%'){
      if(i>0 && (regex[i-1]!='+' && regex[i-1]!='(')) ans.append(".");
    }
    ans.append(string(1,regex[i]));
  }
  return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3861(%rip), %rsi      # 0x7098
movq %r14, %rdi
callq 0x2060
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x3955
movq %rcx, 0x8(%rsp)
leaq 0x383b(%rip), %rdx      # 0x7095
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5232
movl 0x8(%r14), %ebp
testq %rbp, %rbp
je 0x3967
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r12
leaq 0x28(%rsp), %r13
xorl %r15d, %r15d
movq (%r14), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
movb (%rcx,%r15), %al
testq %rdx, %rdx
je 0x38bc
movq %r12, %rsi
xorl %edi, %edi
cmpb %al, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rsi
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x389b
cmpq %r12, %rsi
je 0x38bc
cmpb 0x20(%rsi), %al
jge 0x38c9
movzbl %al, %edx
cmpl $0x28, %edx
je 0x38c9
cmpl $0x40, %edx
jne 0x38d0
testq %r15, %r15
jne 0x38e1
jmp 0x3907
cmpb $0x25, %al
sete %dl
testq %r15, %r15
setne %sil
testb %dl, %sil
je 0x3907
movzbl -0x1(%rcx,%r15), %ecx
cmpl $0x28, %ecx
je 0x3907
cmpl $0x2b, %ecx
je 0x3907
movq %rbx, %rdi
leaq 0x379f(%rip), %rsi      # 0x709a
callq 0x22a0
movq (%r14), %rax
movb (%rax,%r15), %al
movq %r13, 0x18(%rsp)
movsbl %al, %edx
movl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0x21c0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2070
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3947
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
incq %r15
cmpq %rbp, %r15
jne 0x3883
jmp 0x3967
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x519c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x397b
movq %rax, %r14
jmp 0x399a
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x399a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x39b4
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdVec(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double (*)(double))
std::vector<double> toStdVec(Eigen::VectorXd& fromX, double (*f)(double))
{
	std::vector<double> toX(fromX.size(), 0.);
	for (int i=0; i<fromX.size(); i++)
	{
		toX[i] = (*f)(fromX(i));
	}
	return toX;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0xf(%rsp), %rcx
callq 0x13130
cmpq $0x0, 0x8(%r15)
jle 0x135ae
xorl %r12d, %r12d
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
callq *%r14
movq (%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r12, 0x8(%r15)
jg 0x13590
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x135d4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12a60
movq %r14, %rdi
callq 0x131e0
// File: /workspace/github_cpp_makefile_star2_O3/chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdMat(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double (*)(double))
std::vector<std::vector<double>> toStdMat(Eigen::MatrixXd& fromX, double (*f)(double))
{
	std::vector<std::vector<double>> 
	toX(fromX.rows(), std::vector<double>(fromX.cols(), 0.));
	for (int i=0; i<fromX.rows(); i++)
	{
		for (int j=0; j<fromX.cols(); j++)
		{
			toX[i][j] = (*f)(fromX(i, j));
		}
	}
	return toX;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rsi
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x13130
leaq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13642
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12a60
movq 0x8(%r15), %rcx
testq %rcx, %rcx
jle 0x1369e
movq 0x10(%r15), %rax
xorl %r12d, %r12d
testq %rax, %rax
jle 0x13696
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x8(%r15), %rax
cmpq %r12, %rax
jle 0x136b0
imulq %rbp, %rax
shlq $0x3, %rax
addq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
callq *%r14
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r15), %rax
cmpq %rbp, %rax
jg 0x1365d
movq 0x8(%r15), %rcx
incq %r12
cmpq %r12, %rcx
jg 0x13652
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22d5b(%rip), %rdi     # 0x36412
leaq 0x22c67(%rip), %rsi     # 0x36325
leaq 0x22d82(%rip), %rcx     # 0x36447
movl $0x16f, %edx            # imm = 0x16F
callq 0x126a0
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x136fb
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12a60
jmp 0x136fb
movq %rax, %r14
jmp 0x136fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x122f0
movq %r14, %rdi
callq 0x131e0
// File: /workspace/github_cpp_makefile_star2_O3/chrislarson1[P]MVEE/src/mvee.cpp
// Function: mvee::Mvee::compute(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, double, double)
void Mvee::compute(vector<vector<double>>& data, double eps, double lmcoeff)
{
    int rows = data.size();
    int cols = data[0].size();
    MatrixXd D(rows, cols);
    for (int i=0; i<rows; i++)
    {
        for (int j=0; j<cols; j++)
        {
            D(i, j) = data[i][j];
        }
    }
    khachiyan(D, eps, lmcoeff);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r12
movq 0x8(%rax), %r15
subq (%rax), %r15
shrq $0x3, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movslq %r12d, %r8
movslq %r15d, %rcx
movq %rcx, %rax
orq %r8, %rax
js 0x1508a
movq %rsi, %r14
movq %rdi, %rbx
testl %r12d, %r12d
je 0x14fbc
testl %r15d, %r15d
je 0x14fbc
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x150a9
movq %rcx, %rsi
imulq %r8, %rsi
movq %rsp, %rdi
movq %r8, %rdx
callq 0x12170
xorl %eax, %eax
testl %r12d, %r12d
cmovgl %r12d, %eax
jle 0x1503f
movq 0x8(%rsp), %rcx
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq (,%rcx,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
testl %r15d, %r15d
jle 0x15033
cmpq %r8, %rcx
jle 0x1506b
leaq (%r8,%r8,2), %r9
shlq $0x3, %r9
addq (%r14), %r9
movq (%rsp), %r10
addq %rdi, %r10
xorl %r11d, %r11d
cmpq %r11, 0x10(%rsp)
jle 0x1506b
movq (%r9), %r12
movsd (%r12,%r11,8), %xmm0
movsd %xmm0, (%r10)
incq %r11
addq %rsi, %r10
cmpq %r11, %rdx
jne 0x15013
incq %r8
addq $0x8, %rdi
cmpq %rax, %r8
jne 0x14ff4
movq %rsp, %rsi
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x12670
movq (%rsp), %rdi
callq 0x12c20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x213a0(%rip), %rdi     # 0x36412
leaq 0x212ac(%rip), %rsi     # 0x36325
leaq 0x213c7(%rip), %rcx     # 0x36447
movl $0x16f, %edx            # imm = 0x16F
callq 0x126a0
leaq 0x21446(%rip), %rdi     # 0x364d7
leaq 0x215ce(%rip), %rsi     # 0x36666
leaq 0x215fc(%rip), %rcx     # 0x3669b
movl $0x115, %edx            # imm = 0x115
callq 0x126a0
movl $0x8, %edi
callq 0x124f0
movq 0x42efe(%rip), %rcx     # 0x57fb8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x42f08(%rip), %rsi     # 0x57fd0
movq 0x42ed9(%rip), %rdx     # 0x57fa8
movq %rax, %rdi
callq 0x13140
jmp 0x150d9
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x12c20
movq %rbx, %rdi
callq 0x131e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ee3
movl %edi, %ebp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0xb1a9(%rip), %r12      # 0xe04e
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x30a2
movq %r14, %rdi
movq %r12, %rsi
callq 0x20b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2edb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
incq %r13
cmpq %r13, %rbp
jne 0x2ea5
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30a2
cmpq $0x0, 0x8(%rbx)
je 0x2f50
leaq 0xb14a(%rip), %rsi      # 0xe04e
leaq 0x8(%rsp), %rdi
callq 0x20b0
testl %eax, %eax
je 0x2fc2
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30a2
leaq 0x28(%rsp), %rdi
callq 0x2d2e
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f96
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2f96
movq 0xe081(%rip), %rbx      # 0x10fd8
leaq 0xb0f3(%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 0xe04f(%rip), %rdi      # 0x10fd8
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fb1
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 0xe00f(%rip), %rdi      # 0x10fd8
leaq 0xb0a1(%rip), %rsi      # 0xe071
movl $0x18, %edx
callq 0x2230
movq 0xdff7(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfeb(%rip), %rdi      # 0x10fd8
leaq 0xb096(%rip), %rsi      # 0xe08a
movl $0x1f, %edx
callq 0x2230
movq 0xdfd3(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfc7(%rip), %rdi      # 0x10fd8
leaq 0xb092(%rip), %rsi      # 0xe0aa
movl $0x2e, %edx
callq 0x2230
movq 0xdfaf(%rip), %rdi      # 0x10fd8
callq 0x2100
movq 0xdfa3(%rip), %rdi      # 0x10fd8
leaq 0xb09d(%rip), %rsi      # 0xe0d9
movl $0xe, %edx
callq 0x2230
movq 0xdf8b(%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 0x307e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x307e
jmp 0x307b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3099
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31d4
movq %r15, %rdi
callq 0xa642
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa5b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0xa5ed
leaq 0x6f8c(%rip), %rdi      # 0x11548
movq %r14, %rsi
callq 0xa7a4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x31d4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x69e4(%rip), %rdi      # 0x10fd8
leaq 0x3a28(%rip), %rsi      # 0xe023
callq 0x21c0
leaq 0x3dbc(%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 0xa63a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6efb(%rip), %rdi      # 0x11548
movq %rbx, %rsi
callq 0xa7a4
leaq 0x3d87(%rip), %rsi      # 0xe3e3
movq %rax, %rdi
callq 0x20b0
testl %eax, %eax
je 0xa691
leaq 0x6ed9(%rip), %rdi      # 0x11548
movq %rbx, %rsi
callq 0xa7a4
leaq 0x3afb(%rip), %rsi      # 0xe179
movq %rax, %rdi
callq 0x20b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0xa696
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d1b(%rip), %rsi      # 0xe3de
movq %r15, %rdi
callq 0x20b0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0xa6e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0xa750
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 0xad67
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xa735
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa750
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x6df1(%rip), %rdi      # 0x11548
movq %r14, %rsi
callq 0xa7a4
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 0xa795
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3505(%rip), %rdx      # 0xe179
movq %rdx, %rsi
callq 0x326a
addb $-0x28, %bpl
cmpb $0x8, %bpl
jae 0xacb6
movzbl %bpl, %eax
movl $0xaf, %ecx
btl %eax, %ecx
jae 0xacb6
leaq 0x37a9(%rip), %rdx      # 0xe444
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 0xacda
movq (%r15), %rsi
incq %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x342e(%rip), %rsi      # 0xe11b
callq 0x20b0
testl %eax, %eax
je 0xad58
leaq 0x3420(%rip), %rsi      # 0xe11d
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xad58
leaq 0x340f(%rip), %rsi      # 0xe11f
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xad58
leaq 0x33fe(%rip), %rsi      # 0xe121
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xad58
leaq 0x343c(%rip), %rsi      # 0xe172
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0xad58
leaq 0x333f(%rip), %rsi      # 0xe088
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
setne %al
jmp 0xad5a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3b4c
xorl %eax, %eax
retq
subq %rdi, %rsi
leaq 0x2(%rsi), %rax
andq $-0x2, %rax
movq %rdi, %xmm0
pshufd $0x44, %xmm0, %xmm3     # xmm3 = xmm0[0,1,0,1]
paddq 0x184a7(%rip), %xmm3    # 0x1c010
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm2     # xmm2 = xmm0[0,1,0,1]
xorpd %xmm1, %xmm1
movl $0x2, %ecx
movdqa 0x1849c(%rip), %xmm4    # 0x1c020
movdqa 0x184a4(%rip), %xmm5    # 0x1c030
movapd 0x184ac(%rip), %xmm6    # 0x1c040
movdqa 0x184b4(%rip), %xmm7    # 0x1c050
movapd %xmm1, %xmm0
movdqa %xmm4, %xmm1
psubq %xmm3, %xmm1
movdqa %xmm5, %xmm8
psllq %xmm1, %xmm8
pshufd $0xee, %xmm1, %xmm9     # xmm9 = xmm1[2,3,2,3]
movdqa %xmm5, %xmm1
psllq %xmm9, %xmm1
movsd %xmm8, %xmm1            # xmm1 = xmm8[0],xmm1[1]
andpd %xmm6, %xmm1
orpd %xmm0, %xmm1
paddq %xmm7, %xmm3
leaq (%rax,%rcx), %rdx
addq $-0x2, %rdx
addq $-0x2, %rcx
cmpq $0x2, %rdx
jne 0x3b9c
negq %rcx
movq %rcx, %xmm3
pshufd $0x44, %xmm3, %xmm3     # xmm3 = xmm3[0,1,0,1]
por 0x18417(%rip), %xmm3    # 0x1c010
movdqa 0x1845f(%rip), %xmm4    # 0x1c060
pxor %xmm4, %xmm2
pxor %xmm4, %xmm3
movdqa %xmm3, %xmm4
pcmpgtd %xmm2, %xmm4
pshufd $0xa0, %xmm4, %xmm5     # xmm5 = xmm4[0,0,2,2]
pcmpeqd %xmm2, %xmm3
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
pand %xmm5, %xmm2
pshufd $0xf5, %xmm4, %xmm3     # xmm3 = xmm4[1,1,3,3]
por %xmm2, %xmm3
pand %xmm3, %xmm0
pandn %xmm1, %xmm3
por %xmm0, %xmm3
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
por %xmm3, %xmm0
movq %xmm0, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %ecx
shlq $0x30, %rcx
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
orq %rcx, %rax
movq %rax, (%rdi)
movq %rsi, %rcx
shrq $0x29, %rcx
andl $0x7f, %ecx
je 0x3c83
cmpl $0x68, %ecx
je 0x3c83
cmpl $0x7f, %ecx
jne 0x3cab
movabsq $-0xfe0000000001, %rcx  # imm = 0xFFFF01FFFFFFFFFF
andq %rax, %rcx
movabsq $0xd00000000000, %rax   # imm = 0xD00000000000
orq %rcx, %rax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20326(%rip), %rax     # 0x23fd8
movq (%rax), %rcx
leaq 0x18e8e(%rip), %rdi     # 0x1cb4a
movl $0x11, %esi
movl $0x1, %edx
callq 0x3480
movq (%r14), %rax
jmp 0x3c83
// File: /workspace/github_cpp_makefile_star2_O3/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 0x204e7(%rip), %rdi     # 0x24270
leaq (%rdi,%rsi), %rax
cmpq $0x8001, %rax           # imm = 0x8001
jae 0x3da8
movq %rax, 0x204d4(%rip)     # 0x24270
leaq 0x20a1d(%rip), %rax     # 0x247c0
leaq (%rax,%rdi,8), %rax
retq
pushq %rax
callq 0x3507
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: rollup(void*)
void rollup(void * p)
{
    if (p < heap || p > heap + avail) {
        fprintf(stderr, "Cannot rollup from %p to %p\n", (void*)(heap + avail), p);
        exit(1);
    }
    avail = reinterpret_cast<int64_t*>(p) - heap;
    if (heap + avail != p) {
        fprintf(stderr, "Cannot rollup to unaligned pointer %p\n", p);
        exit(1);
    }
}

// Assembly:
movq %rdi, %rsi
leaq 0x20a08(%rip), %rcx     # 0x247c0
movq %rdi, %rax
movq 0x204ae(%rip), %rdi     # 0x24270
subq %rcx, %rax
jb 0x3ddc
leaq (%rcx,%rdi,8), %rcx
cmpq %rsi, %rcx
jb 0x3ddc
sarq $0x3, %rax
movq %rax, 0x20495(%rip)     # 0x24270
retq
pushq %rax
callq 0x3552
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3dee
xorl %eax, %eax
retq
movq 0x2047b(%rip), %rsi     # 0x24270
testq %rdi, %rdi
js 0x3e0b
cmpq %rdi, %rsi
jle 0x3e0b
leaq 0x209ba(%rip), %rax     # 0x247c0
leaq (%rax,%rdi,8), %rax
retq
pushq %rax
callq 0x3584
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e4f
movq 0x20453(%rip), %rax     # 0x24270
cmpq %rdi, %rax
setg %cl
cmpq $0x65, %rdi
setl %dl
orb %cl, %dl
jne 0x3e54
leaq 0x2098b(%rip), %rdx     # 0x247c0
movq %rdi, %rcx
leaq (%rdx,%rax,8), %rsi
subq %rdx, %rcx
jb 0x3e58
cmpq %rdi, %rsi
jbe 0x3e58
sarq $0x3, %rcx
movq %rcx, %rdi
jmp 0x3e54
movl $0x7800, %edi           # imm = 0x7800
movq %rdi, %rax
retq
pushq %rax
callq 0x35ab
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e90
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3ed5
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x503f
leal -0x10(%rax), %ecx
cmpl $0x9, %ecx
ja 0x5043
orb $0x20, %al
jmp 0x5064
movb $0x20, %al
jmp 0x5064
leal -0x21(%rax), %ecx
cmpl $0x19, %ecx
ja 0x504f
addb $0x20, %al
jmp 0x5064
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 0x5025
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x509c
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x510f
leaq 0x17bba(%rip), %rsi     # 0x1cc8d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x30b0
testl %eax, %eax
js 0x5133
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 0x3380
movq (%rsp), %rdi
callq 0x32e0
jmp 0x5124
movsbl %dl, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3450
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17b59(%rip), %rdi     # 0x1cc93
callq 0x31f0
jmp 0x5124
jmp 0x5143
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x515a
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5633
leaq 0x17ce7(%rip), %rdi     # 0x1d2f1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
addq $-0x4e, %rbx
cmpq $0x8, %rbx
ja 0x56be
movl $0x103, %eax            # imm = 0x103
btq %rbx, %rax
jae 0x56be
popq %rbx
retq
cmpq $0x59, %rbx
jl 0x5678
movl $0x56, %edi
callq 0x55ec
movq %rbx, %rdi
callq 0x5425
leaq 0x17cb7(%rip), %rdi     # 0x1d309
movq %rax, %rsi
xorl %eax, %eax
callq 0x3030
cmpq $0x16, %rbx
je 0x56a9
cmpq $0x11, %rbx
jne 0x5614
movq 0x5f2f9(%rip), %rsi     # 0x64968
leaq 0x17c8a(%rip), %rdi     # 0x1d300
jmp 0x56b7
cmpq $0x14, %rbx
jne 0x56c9
xorl %eax, %eax
cmpl $0x0, 0x5f195(%rip)     # 0x6481c
sete %al
leaq 0x1(,%rax,2), %rbx
movq %rbx, %rdi
callq 0x5425
leaq 0x17c68(%rip), %rdi     # 0x1d309
movq %rax, %rsi
jmp 0x560d
movq 0x5f230(%rip), %rsi     # 0x648e0
leaq 0x17c56(%rip), %rdi     # 0x1d30d
xorl %eax, %eax
callq 0x3030
movl $0xa, %edi
popq %rbx
jmp 0x3330
leaq -0x10(%rbx), %rax
cmpq $0x2, %rax
ja 0x5643
movq 0x5f34a(%rip), %rsi     # 0x64a28
shlq $0x17, %rsi
sarq $0x17, %rsi
leaq 0x17c17(%rip), %rdi     # 0x1d304
xorl %eax, %eax
callq 0x3030
jmp 0x5643
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ff9
movq (%rbx), %rdi
decq %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x5712
movq 0x1e865(%rip), %rax     # 0x23f88
movq (%rax), %rsi
callq 0x32b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5746
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5777
incq %rdi
xorl %eax, %eax
leaq 0xb7ad2(%rip), %rdx     # 0xbd230
shlq $0x6, %rax
movzbl %cl, %ecx
movsbq (%rcx,%rdx), %rcx
orq %rcx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x575e
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5f13f(%rip), %rax     # 0x648c0
cmpq %rax, 0x5f338(%rip)     # 0x64ac0
jge 0x585d
pushq %r14
pushq %rbx
pushq %rax
movl $0x38, %edi
callq 0x3d77
movq %rax, %rbx
movl $0x1, %r14d
movq %r14, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
movl $0x40, %edi
callq 0x3d77
movq %rax, %rcx
movq 0x5f22d(%rip), %rsi     # 0x649f8
xorl %edi, %edi
movq %rdi, (%rax)
movl $0x5, 0x10(%rax)
movq %r14, (%rbx)
movq %rdi, 0x20(%rbx)
movq $0xc, 0x8(%rbx)
movq 0x5f1fb(%rip), %rax     # 0x649e8
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x5f0c4(%rip), %r8      # 0x648c0
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 0x5f098(%rip), %rax     # 0x648c0
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 0x5868
leaq 0x5f26c(%rip), %rcx     # 0x64ad0
movq (%rcx,%rax,8), %rcx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5f074(%rip), %rax     # 0x64938
leaq 0xa7955(%rip), %rcx     # 0xad220
movq %rdi, (%rcx,%rax,8)
incq 0x5efb2(%rip)           # 0x64888
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x58f4
pushq %rax
movl $0x31, %edi
callq 0x58ff
movl $0x1, %eax
addq $0x8, %rsp
jmp 0x58f7
incq %rax
movq %rax, 0x5f03a(%rip)     # 0x64938
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x5f06b(%rip)      # 0x64976
movb %al, 0x5f06c(%rip)      # 0x6497d
movq 0x5ef58(%rip), %rax     # 0x64870
cmpq 0x5ef59(%rip), %rax     # 0x64878
setne %dl
movq 0x5ef57(%rip), %rcx     # 0x64880
cmpq $0xa, %rcx
setl %sil
cmpq $0x34, %rdi
je 0x593c
andb %sil, %dl
je 0x5982
incq 0x5ef65(%rip)           # 0x648a8
leaq 0x63c36(%rip), %rdx     # 0x69580
movq %rax, (%rdx,%rcx,8)
incq %rcx
movq %rcx, 0x5ef28(%rip)     # 0x64880
movq %rax, 0x5ef19(%rip)     # 0x64878
leaq 0x179f5(%rip), %rdi     # 0x1d35b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
movq %rbx, %rdi
callq 0x55ec
cmpq $0x3d, 0x5ef28(%rip)    # 0x648a8
jge 0x5984
popq %rbx
retq
movl $0xa, %edi
callq 0x3330
callq 0x65eb
movl $0x35, %edi
callq 0x55ec
callq 0x7fec
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c48
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 0x3c48
movq (%r14), %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq 0x63aeb(%rip), %rax     # 0x694d8
jne 0x5a6b
movq 0x5ef62(%rip), %rdx     # 0x64958
cmpq %rax, %rdx
je 0x5a8f
movb 0x5ef6f(%rip), %cl      # 0x64974
movl %ecx, %esi
xorb $0x1, %sil
cmpq $0x1, %rdx
setne %dl
orb %sil, %dl
jne 0x5a71
movq 0x5ef1a(%rip), %rdx     # 0x64938
leaq 0xa77fb(%rip), %rsi     # 0xad220
movq -0x8(%rsi,%rdx,8), %rdi
movq %rdi, %r8
shrq $0x27, %r8
cmpl $0x1b9, %r8d            # imm = 0x1B9
jne 0x5a71
movq %rax, 0x5ef17(%rip)     # 0x64958
shrq $0x18, %rdi
movl $0x7fff, %eax           # imm = 0x7FFF
andq %rax, %rdi
andq %rax, %rbx
shlq $0x18, %rbx
orq %rdi, %rbx
movabsq $0xda00000c0000, %rax   # imm = 0xDA00000C0000
orq %rbx, %rax
movq %rax, -0x8(%rsi,%rdx,8)
jmp 0x5a8f
movb 0x5ef03(%rip), %cl      # 0x64974
movq %rax, 0x5eee0(%rip)     # 0x64958
testb $0x1, %cl
je 0x5a97
shlq $0x18, %rbx
movq %rbx, 0x5efb0(%rip)     # 0x64a38
movb $0x0, 0x5eee5(%rip)     # 0x64974
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x5eed6(%rip)     # 0x64974
andl $0xffffff, %ebx         # imm = 0xFFFFFF
orq 0x5ef8d(%rip), %rbx     # 0x64a38
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x58bd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ee1e(%rip), %rax     # 0x64958
cmpq 0x63997(%rip), %rax     # 0x694d8
je 0x5b8b
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x5ee23(%rip), %bpl     # 0x64974
movq 0x5ede0(%rip), %rax     # 0x64938
leaq 0x1000(%rax), %r14
testb %bpl, %bpl
cmoveq %rax, %r14
movq (%rdi), %rdi
addq 0x5ec90(%rip), %rdi     # 0x64800
callq 0x59a2
xorl %eax, %eax
cmpb %bpl, 0x5edf6(%rip)     # 0x64974
sete %al
subq %rax, %r14
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ec57(%rip), %rax     # 0x64838
leaq 0x65108(%rip), %rcx     # 0x6acf0
movq %rdi, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x5c0a
pushq %rax
movl $0x32, %edi
callq 0x58ff
movl $0x7800, %eax           # imm = 0x7800
addq $0x8, %rsp
jmp 0x5c0d
incq %rax
movq %rax, 0x5ec24(%rip)     # 0x64838
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5ec15(%rip), %rbx     # 0x64838
movq 0x5ee06(%rip), %rax     # 0x64a30
testl $0xffffff, %eax         # imm = 0xFFFFFF
je 0x5c97
movq 0xa50b8(%rip), %rdx     # 0xaacf0
testq %rdx, %rdx
jle 0x5c9f
xorl %ecx, %ecx
leaq 0xa539a(%rip), %rsi     # 0xaafe0
cmpq 0x8(%rsi,%rcx,8), %rax
je 0x5d06
incq %rcx
cmpq %rcx, %rdx
jne 0x5c46
leaq 0x1(%rdx), %rsi
movq %rsi, 0xa508c(%rip)     # 0xaacf0
movq %rbx, %rcx
cmpq $0x59, %rdx
jl 0x5caf
movl $0x33, %edi
callq 0x58ff
movq $0x1, 0xa506e(%rip) # 0xaacf0
movq 0x5ebaf(%rip), %rcx     # 0x64838
movl $0x1, %esi
movq 0x5ed9b(%rip), %rax     # 0x64a30
jmp 0x5caf
orq %rax, %r14
movq %rbx, %rcx
jmp 0x5ccc
incq %rdx
movq %rdx, 0xa5047(%rip)     # 0xaacf0
movq %rdx, %rsi
movq %rbx, %rcx
leaq 0xa504a(%rip), %rdx     # 0xaad00
movq %rcx, (%rdx,%rsi,8)
leaq 0xa531f(%rip), %rdx     # 0xaafe0
movq %rax, (%rdx,%rsi,8)
orq $0x400000, %r14         # imm = 0x400000
leaq 0x6501d(%rip), %rax     # 0x6acf0
movq %r14, (%rax,%rcx,8)
cmpq $0x7fff, %rcx           # imm = 0x7FFF
jne 0x5cf1
movl $0x32, %edi
callq 0x58ff
movl $0x7800, %ecx           # imm = 0x7800
jmp 0x5cf4
incq %rcx
movq %rcx, 0x5eb3d(%rip)     # 0x64838
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xa4ff3(%rip), %rax     # 0xaad00
movq 0x8(%rax,%rcx,8), %rbx
jmp 0x5cfb
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x64cb1(%rip), %r14     # 0x6a9d0
movq (%r14,%rdi,8), %rax
testq %rax, %rax
jne 0x5d4b
movq %rdi, %rbx
leaq 0x1e64e(%rip), %rax     # 0x24380
movq (%rax,%rdi,8), %rax
movq %rax, 0x5ecf3(%rip)     # 0x64a30
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5c15
movq %rax, (%r14,%rbx,8)
addq $0xdc8000, %rax         # imm = 0xDC8000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5eb85(%rip), %rax     # 0x64930
testq %rax, %rax
je 0x5e8c
movabsq $0xffffffffffff, %rdi   # imm = 0xFFFFFFFFFFFF
movq 0x5ec6b(%rip), %rcx     # 0x64a30
movq %rcx, %r8
andq %rdi, %r8
movl $0x1, %r10d
leaq 0xa54e8(%rip), %rdx     # 0xab2c0
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 0x5eba
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 0x5e27
leaq -0x1(%rsi), %r9
movq %r10, %rbx
movq %rbx, %r10
cmpq %r9, %rbx
jle 0x5ddb
movq 0x5e9fa(%rip), %rbx     # 0x64830
cmpq $0x1f4, %rax            # imm = 0x1F4
je 0x5eb3
btq $0x2f, %r11
cmovaeq %r14, %rsi
cmpq %rsi, %rax
jl 0x5e71
leaq 0x1(%rax), %rdi
leaq 0xa6419(%rip), %r8      # 0xac270
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 0x5e57
incq %rax
movq %rax, 0x5eab5(%rip)     # 0x64930
movq %rcx, (%rdx,%rsi,8)
leaq 0xa63ea(%rip), %rax     # 0xac270
movq %rbx, (%rax,%rsi,8)
jmp 0x5eb3
movq 0x5e99d(%rip), %rbx     # 0x64830
movq $0x1, 0x5ea92(%rip) # 0x64930
movq 0x5eb8b(%rip), %rax     # 0x64a30
movq %rax, 0xa541c(%rip)     # 0xab2c8
movq %rbx, 0xa63c5(%rip)     # 0xac278
callq 0x5d59
jmp 0x5ec5
leaq 0xa63af(%rip), %rax     # 0xac270
movq (%rax,%rsi,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5e95a(%rip), %rbx     # 0x64838
movq 0x5ec23(%rip), %rax     # 0x64b08
testq %rax, %rax
je 0x5f45
movl $0x1, %edi
leaq 0x5ec1a(%rip), %rcx     # 0x64b10
movq %rax, %r8
leaq (%r8,%rdi), %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
addq %rdx, %rsi
sarq %rsi
movq (%rcx,%rsi,8), %r9
cmpq %r14, %r9
je 0x5f60
leaq 0x1(%rsi), %rdx
cmpq %r14, %r9
jg 0x5f21
movq %rdx, %rdi
jmp 0x5f25
leaq -0x1(%rsi), %r8
cmpq %rdi, %r8
jge 0x5ef9
cmpq $0x3e8, %rax            # imm = 0x3E8
jl 0x5f6d
movl $0x32, %edi
callq 0x58ff
movq 0x5e8f5(%rip), %rax     # 0x64838
jmp 0x5fba
movq $0x1, 0x5ebb8(%rip) # 0x64b08
movq %r14, 0x5ebc1(%rip)     # 0x64b18
movq %rbx, 0x60b0a(%rip)     # 0x66a68
jmp 0x5fb7
leaq 0x60af9(%rip), %rax     # 0x66a60
movq (%rax,%rsi,8), %rbx
jmp 0x5fe8
cmpq %r14, %r9
cmovgq %rsi, %rdx
cmpq %rdx, %rax
jl 0x5f9e
leaq 0x1(%rax), %rsi
leaq 0x60adc(%rip), %rdi     # 0x66a60
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 0x5f84
incq %rax
movq %rax, 0x5eb60(%rip)     # 0x64b08
movq %r14, (%rcx,%rdx,8)
leaq 0x60aad(%rip), %rax     # 0x66a60
movq %rbx, (%rax,%rdx,8)
movq %rbx, %rax
leaq 0x64d2f(%rip), %rcx     # 0x6acf0
movq %r14, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x5fde
movl $0x32, %edi
callq 0x58ff
movl $0x7800, %eax           # imm = 0x7800
jmp 0x5fe1
incq %rax
movq %rax, 0x5e850(%rip)     # 0x64838
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5da0
movq %rax, %rbx
cmpq $0x800, %rax            # imm = 0x800
jl 0x6032
cmpq $0x1000, %rbx           # imm = 0x1000
jb 0x6019
movl $0xcc, %edi
callq 0x58ff
jmp 0x6032
orq $0x800000, %rbx         # imm = 0x800000
movq %rbx, %rdi
callq 0x5ed0
movq %rax, %rbx
addq $-0x7000, %rbx          # imm = 0x9000
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x608a
incq %rax
leaq -0x1(%rcx), %rdx
andq %rdx, %rcx
jne 0x607e
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60da
movabsq $0x7fffffffffff, %rcx   # imm = 0x7FFFFFFFFFFF
leaq 0x1(%rcx), %rdx
movl $0x30, %eax
testq %rdx, %rdi
je 0x60e0
retq
movl $0x31, %eax
retq
andq %rcx, %rdi
bsrq %rdi, %rax
xorq $-0x40, %rax
addq $0x41, %rax
retq