LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: Kleeny(NFA&)
NFA Kleeny(NFA& A){
  NFA B=A;
  for(uLong f:B.acceptStates)
    B.addTransition(f,0,'@');
  B.acceptStates.insert(0);
  return B;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3b8e
leaq 0x20(%rbx), %r14
movq 0x38(%rbx), %r15
leaq 0x28(%rbx), %r12
pushq $0x40
popq %rbp
cmpq %r12, %r15
je 0x29ff
movq 0x20(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x2644
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
jmp 0x29dd
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %r14, %rdi
callq 0x4a92
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a22
movq %rax, %r14
movq %rbx, %rdi
callq 0x3b6a
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: concat(NFA&, NFA&)
NFA concat(NFA& A, NFA& B){
  NFA C(A.noStates+B.noStates,A.alphabet);
  for(uLong i=0;i<A.noStates;i++){
    for(auto pb: A.Trans[i])
      C.addTransition(i,pb.second,pb.first);
  }
  for(uLong i=0;i<B.noStates;i++){
    for(auto pb: B.Trans[i])
      C.addTransition(i+A.noStates,pb.second+A.noStates,pb.first);
  }
  for(uLong f:A.acceptStates)
    C.addTransition(f,A.noStates,'@');
  for(uLong f: B.acceptStates)
    C.acceptStates.insert(f+A.noStates);

  return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rsi
addq (%r15), %rsi
leaq 0x50(%r15), %rdx
callq 0x23fc
xorl %r12d, %r12d
cmpq (%r15), %r12
jae 0x2a9f
movq 0x8(%r15), %rax
imulq $0x30, %r12, %rcx
leaq (%rax,%rcx), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r13
cmpq %rbp, %r13
je 0x2a9a
movsbl 0x20(%r13), %ecx
movq 0x28(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2644
movq %r13, %rdi
callq 0x21a0
movq %rax, %r13
jmp 0x2a74
incq %r12
jmp 0x2a5b
xorl %r13d, %r13d
cmpq (%r14), %r13
jae 0x2aec
movq 0x8(%r14), %rax
imulq $0x30, %r13, %rcx
leaq (%rax,%rcx), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r12
cmpq %rbp, %r12
je 0x2ae7
movsbl 0x20(%r12), %ecx
movq (%r15), %rdx
leaq (%rdx,%r13), %rsi
addq 0x28(%r12), %rdx
movq %rbx, %rdi
callq 0x2644
movq %r12, %rdi
callq 0x21a0
movq %rax, %r12
jmp 0x2abb
incq %r13
jmp 0x2aa2
movq 0x38(%r15), %r12
leaq 0x28(%r15), %r13
pushq $0x40
popq %rbp
cmpq %r13, %r12
je 0x2b1b
movq 0x20(%r12), %rsi
movq (%r15), %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x2644
movq %r12, %rdi
callq 0x21a0
movq %rax, %r12
jmp 0x2af7
movq 0x38(%r14), %r13
addq $0x28, %r14
leaq 0x20(%rbx), %r12
movq %rsp, %rbp
cmpq %r14, %r13
je 0x2b52
movq 0x20(%r13), %rax
addq (%r15), %rax
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4a92
movq %r13, %rdi
callq 0x21a0
movq %rax, %r13
jmp 0x2b2a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b6a
jmp 0x2b6a
jmp 0x2b6a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3b6a
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: printNFA(NFA&)
void printNFA(NFA& A){
  cout<<A.noStates<<endl;
  for(char c:A.alphabet)
    cout<<c<<" ";
  cout<<endl;
  for(uLong f: A.acceptStates)
    cout<<f<<" ";
  cout<<endl;
  for(uLong i=0;i<A.noStates;i++){
    for(auto pb: A.Trans[i])
      cout<<i<<" "<<pb.second<<" "<<pb.first<<endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movq (%rdi), %rsi
movq 0x80e1(%rip), %r14      # 0xafc8
movq %r14, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20c0
movq 0x50(%r13), %rbx
movq 0x58(%r13), %r12
leaq 0x4190(%rip), %r15      # 0x7096
cmpq %r12, %rbx
je 0x2f26
movsbl (%rbx), %esi
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
incq %rbx
jmp 0x2f06
movq 0x809b(%rip), %r14      # 0xafc8
movq %r14, %rdi
callq 0x20c0
movq 0x38(%r13), %r12
leaq 0x28(%r13), %rbx
leaq 0x4152(%rip), %r15      # 0x7096
cmpq %rbx, %r12
je 0x2f6e
movq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x2110
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %r12, %rdi
callq 0x21a0
movq %rax, %r12
jmp 0x2f44
movq 0x8053(%rip), %rdi      # 0xafc8
callq 0x20c0
xorl %r15d, %r15d
leaq 0x4112(%rip), %r12      # 0x7096
movq %r13, (%rsp)
cmpq (%r13), %r15
jae 0x3008
movq 0x8(%r13), %rax
imulq $0x30, %r15, %rcx
leaq (%rax,%rcx), %r14
addq $0x8, %r14
movq 0x10(%r14), %r13
cmpq %r14, %r13
je 0x2fff
movsbl 0x20(%r13), %ebp
movq 0x28(%r13), %rbx
movq 0x8011(%rip), %rdi      # 0xafc8
movq %r15, %rsi
callq 0x2110
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movl %ebp, %esi
callq 0x21c0
movq %rax, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x21a0
movq %rax, %r13
jmp 0x2fa2
incq %r15
movq (%rsp), %r13
jmp 0x2f88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: NFA::acceptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool NFA::acceptString(string st){
  set<uLong> currStates;
  currStates.insert(0);
  currStates=step(currStates,'@');
  for(char c:st){
    currStates=step(currStates,c);
  }
  for(uLong f: acceptStates)
    if(currStates.find(f)!=currStates.end()) return true;
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x4a92
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rdx
pushq $0x40
popq %rcx
movq %rbx, %rsi
callq 0x267c
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x474a
movq %r12, %rdi
callq 0x3d00
movq (%r14), %rbp
movq 0x8(%r14), %r14
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x30c6
movsbl (%rbp,%r13), %ecx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x267c
movq %r15, %rdi
movq %r12, %rsi
callq 0x474a
movq %r12, %rdi
callq 0x3d00
incq %r13
jmp 0x3095
movq 0x38(%rbx), %r14
addq $0x28, %rbx
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpq %rbx, %r14
je 0x3108
movq 0x20(%r14), %rax
movq %rax, 0x38(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4df0
cmpq %r13, %rax
jne 0x3108
movq %r14, %rdi
callq 0x21a0
movq %rax, %r14
jmp 0x30dd
cmpq %rbx, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x3d00
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x312f
jmp 0x312f
jmp 0x312f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d00
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3f36(%rip), %rsi      # 0x7098
movq %r14, %rdi
callq 0x3c38
testb %al, %al
je 0x3181
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rbx, %rax
jmp 0x324b
leaq 0x3f0d(%rip), %rsi      # 0x7095
leaq 0x8(%rsp), %r12
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3c46
movl 0x8(%r14), %ebp
movq %r15, %rbx
leaq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x3247
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x512e
movq (%r14), %rcx
cmpq %r13, %rax
je 0x31f3
testq %r15, %r15
je 0x3211
movzbl -0x1(%rcx,%r15), %eax
cmpl $0x28, %eax
je 0x3211
cmpl $0x2b, %eax
je 0x3211
movq (%rsp), %rdi
leaq 0x3eb1(%rip), %rsi      # 0x709a
callq 0x2290
movq (%r14), %rcx
jmp 0x3211
movzbl (%rcx,%r15), %eax
cmpl $0x28, %eax
je 0x31c9
cmpl $0x40, %eax
je 0x31c9
cmpb $0x25, %al
sete %al
testq %r15, %r15
setne %dl
testb %al, %dl
jne 0x31ce
movsbl (%rcx,%r15), %edx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x21b0
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x22a0
movq %r12, %rdi
callq 0x20a0
incq %r15
jmp 0x31aa
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x326d
jmp 0x326d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x3270
movq %rax, %r14
movq (%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: inputNFA()
NFA inputNFA(){
  int nS;
  std::vector<char> alpha;
  string line;
  cin>>nS;
  getline(cin,line);
  getline(cin,line);
  for(char c:line)
    if(!(c==' '||c=='\n')) alpha.push_back(c);
  NFA ans(nS,alpha);
  getline(cin,line);
  istringstream is {line};
  while(is>>nS){
    ans.acceptStates.insert(nS);
  }
  int p,q; char al;
  while(cin>>p>>q>>al)
    ans.Trans[p].insert(make_pair(al,q));
  return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
andq $0x0, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x79d7(%rip), %rdi      # 0xafd8
leaq 0x4(%rsp), %rsi
callq 0x2100
movq 0x79c6(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
movq 0x79b5(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r13
xorl %ebp, %ebp
leaq 0x40(%rsp), %r14
leaq 0x58(%rsp), %r15
cmpq %rbp, %r13
je 0x366b
movzbl (%r12,%rbp), %eax
movb %al, 0x58(%rsp)
cmpl $0xa, %eax
je 0x3666
cmpl $0x20, %eax
je 0x3666
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c1e
incq %rbp
jmp 0x3643
movslq 0x4(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x23fc
movq 0x7954(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2260
leaq 0x20(%rbx), %r14
leaq 0x58(%rsp), %r15
leaq 0x4(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x36e3
movslq 0x4(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x4a92
jmp 0x36b3
movq 0x78ee(%rip), %r14      # 0xafd8
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x3(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3756
movslq 0xc(%rsp), %rax
imulq $0x30, %rax, %rdi
addq 0x8(%rbx), %rdi
movb 0x3(%rsp), %al
movslq 0x8(%rsp), %rcx
movb %al, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rbp, %rsi
callq 0x4ba8
jmp 0x36fe
leaq 0x58(%rsp), %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x457e
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x378b
movq %rax, %r14
jmp 0x37aa
jmp 0x3792
movq %rax, %r14
jmp 0x37b2
jmp 0x379d
jmp 0x379d
jmp 0x379d
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x3b6a
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x457e
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/Resource.cpp
// Function: inputDFA()
NFA inputDFA(){
  int nS;
  std::vector<char> alpha;
  string line;
  cin>>nS;
  getline(cin,line);
  getline(cin,line);
  for(char c:line)
    if(!(c==' '||c=='\n')) alpha.push_back(c);
  NFA ans(nS,alpha);
  getline(cin,line);
  istringstream is {line};
  while(is>>nS){
    ans.acceptStates.insert(nS);
  }
  int p,q; char al;
  uLong ct=0;
  while((ct++)<ans.noStates*ans.alphabet.size() && cin>>p>>q>>al)
    ans.Trans[p].insert(make_pair(al,q));
  return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
andq $0x0, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x778a(%rip), %rdi      # 0xafd8
leaq 0x4(%rsp), %rsi
callq 0x2100
movq 0x7779(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
movq 0x7768(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r13
xorl %ebp, %ebp
leaq 0x40(%rsp), %r14
leaq 0x58(%rsp), %r15
cmpq %rbp, %r13
je 0x38b8
movzbl (%r12,%rbp), %eax
movb %al, 0x58(%rsp)
cmpl $0xa, %eax
je 0x38b3
cmpl $0x20, %eax
je 0x38b3
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c1e
incq %rbp
jmp 0x3890
movslq 0x4(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x23fc
movq 0x7707(%rip), %rdi      # 0xafd8
leaq 0x20(%rsp), %rsi
callq 0x2040
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2260
leaq 0x20(%rbx), %r14
leaq 0x58(%rsp), %r15
leaq 0x4(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3930
movslq 0x4(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x4a92
jmp 0x3900
xorl %r14d, %r14d
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x3(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
imulq (%rbx), %rax
cmpq %rax, %r14
jae 0x39b7
movq 0x7679(%rip), %rdi      # 0xafd8
movq %r15, %rsi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x39b7
movslq 0xc(%rsp), %rax
imulq $0x30, %rax, %rdi
addq 0x8(%rbx), %rdi
movb 0x3(%rsp), %al
movslq 0x8(%rsp), %rcx
movb %al, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rbp, %rsi
callq 0x4ba8
incq %r14
jmp 0x3947
leaq 0x58(%rsp), %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x457e
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39ec
movq %rax, %r14
jmp 0x3a0b
jmp 0x39f3
movq %rax, %r14
jmp 0x3a13
jmp 0x39fe
jmp 0x39fe
jmp 0x39fe
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x3b6a
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x457e
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/kage08[P]RegexLibrary/REGEX2NFA.cpp
// Function: main
int main(){
  set<char> alphabet;
  string line;
  getline(cin,line);
  for(char c:line){
    if(!(c==' ' || c=='\n')) alphabet.insert(c);
  }
  cin>>line;
  string ln;
  for(char c:line) if(c!=' ') ln.append(string(1,c));
  line=ln;
  //cout<<line<<endl;
  line=addConcat(line,alphabet);
  //cout<<line<<endl;
  line=toPostFix(line,alphabet);
  //cout<<line<<endl;
  NFA C=makeNFA(line,alphabet);
  printNFA(C);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
leaq 0x48(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x5505(%rip), %rdi      # 0xafd8
movq %rsp, %rsi
callq 0x2040
movq (%rsp), %r15
movq 0x8(%rsp), %r12
xorl %r13d, %r13d
leaq 0x40(%rsp), %rbx
leaq 0x70(%rsp), %r14
cmpq %r13, %r12
je 0x5b19
movzbl (%r15,%r13), %eax
movb %al, 0x70(%rsp)
cmpl $0xa, %eax
je 0x5b14
cmpl $0x20, %eax
je 0x5b14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f34
incq %r13
jmp 0x5af1
movq 0x54b8(%rip), %rdi      # 0xafd8
movq %rsp, %rsi
callq 0x21f0
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsp), %r12
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
leaq 0x70(%rsp), %rbx
pushq $0x1
popq %r14
leaq 0x20(%rsp), %r15
cmpq %rbp, %r13
je 0x5b92
movb (%r12,%rbp), %al
cmpb $0x20, %al
je 0x5b8d
leaq 0x80(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22a0
movq %rbx, %rdi
callq 0x20a0
incq %rbp
jmp 0x5b52
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x20e0
leaq 0x108(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5d04
leaq 0x70(%rsp), %rdi
movq %rsp, %rsi
leaq 0x108(%rsp), %rdx
callq 0x3144
movq %rsp, %rdi
leaq 0x70(%rsp), %rbx
movq %rbx, %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x20a0
leaq 0x108(%rsp), %rdi
callq 0x5f20
leaq 0xd8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5d04
leaq 0x70(%rsp), %rdi
movq %rsp, %rsi
leaq 0xd8(%rsp), %rdx
callq 0x3281
movq %rsp, %rbx
leaq 0x70(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x20a0
leaq 0xd8(%rsp), %rdi
callq 0x5f20
leaq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rsi
callq 0x2b7d
leaq 0x70(%rsp), %rdi
callq 0x2ecf
leaq 0x70(%rsp), %rdi
callq 0x3b6a
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x5f20
xorl %eax, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3b6a
jmp 0x5cdf
jmp 0x5ccd
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
jmp 0x5cbb
jmp 0x5ccd
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x5f20
jmp 0x5cdf
jmp 0x5ccd
jmp 0x5ccd
jmp 0x5cc8
movq %rax, %rbx
jmp 0x5ce9
movq %rax, %rbx
jmp 0x5cdf
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x5f20
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdx)
leaq 0xf(%rsp), %rcx
callq 0x59a30
xorl %r12d, %r12d
cmpq %r12, 0x8(%r15)
jle 0x5a90b
movq %r15, %rdi
movq %r12, %rsi
callq 0x5a640
movsd (%rax), %xmm0
callq *%r14
movq (%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x5a8e5
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59aa0
movq %r14, %rdi
callq 0x59d40
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x59a30
leaq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x567e0
leaq 0x8(%rsp), %rdi
callq 0x59aa0
xorl %r12d, %r12d
cmpq %r12, 0x8(%r15)
jle 0x5a9c5
imulq $0x18, %r12, %rbp
xorl %r13d, %r13d
cmpq %r13, 0x10(%r15)
jle 0x5a9c0
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x58fd0
movsd (%rax), %xmm0
callq *%r14
movq (%rbx), %rax
movq (%rax,%rbp), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x5a993
incq %r12
jmp 0x5a986
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x59aa0
jmp 0x5a9f6
movq %rax, %r14
jmp 0x5a9f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x55c80
movq %r14, %rdi
callq 0x59d40
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movq %rdi, %r14
shrq $0x3, %rax
movq %rsp, %rdx
movl %eax, (%rdx)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x597c0
xorl %r12d, %r12d
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
jge 0x5b6bc
imulq $0x18, %r12, %rbp
xorl %r13d, %r13d
movslq (%rsp), %rax
cmpq %rax, %r13
jge 0x5b6b7
movq (%rbx), %rax
movq (%rax,%rbp), %rax
movsd (%rax,%r13,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x58fd0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
jmp 0x5b67e
incq %r12
jmp 0x5b66d
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x56c10
movq 0x20(%rsp), %rdi
callq 0x583e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b6f0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x583e0
movq %rbx, %rdi
callq 0x59d40
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x22c0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x2aac
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
leaq 0x6610(%rip), %r12      # 0x905d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a7e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2330
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2310
jmp 0x2a4d
movq %rsp, %rdi
callq 0x2110
leaq 0x20(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa515(%rip), %rdi      # 0xcfc8
leaq 0x657a(%rip), %rsi      # 0x9034
callq 0x21d0
leaq 0x657a(%rip), %rsi      # 0x9040
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x657a(%rip), %rsi      # 0x905a
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
xorl %edi, %edi
callq 0x2230
movq %rax, %r14
jmp 0x2b16
movq %rax, %r14
jmp 0x2b0c
movq %rax, %r14
movq %rsp, %rdi
callq 0x2110
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edi, %r14d
xorl %ebp, %ebp
testl %edi, %edi
cmovlel %ebp, %r14d
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
leaq 0x6449(%rip), %r13      # 0x905f
cmpq %rbp, %r14
je 0x2c42
movq (%rbx,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2d6a
movq %r15, %rdi
movq %r13, %rsi
callq 0x2e1b
movq %r15, %rdi
callq 0x2110
incq %rbp
jmp 0x2c16
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2d6a
cmpq $0x0, 0x8(%rbx)
je 0x2c9a
leaq 0x63fc(%rip), %rsi      # 0x905f
leaq 0x8(%rsp), %rdi
callq 0x2e1b
testb %al, %al
jne 0x2cd0
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2d6a
leaq 0x28(%rsp), %rdi
callq 0x2b26
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x2cb5
movq 0xa327(%rip), %rdi      # 0xcfc8
leaq 0x63ba(%rip), %rsi      # 0x9062
callq 0x21d0
movq %rax, %rdi
callq 0x2120
leaq 0x8(%rsp), %rdi
callq 0x2110
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa2f1(%rip), %rdi      # 0xcfc8
leaq 0x63a4(%rip), %rsi      # 0x9082
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq 0xa2d6(%rip), %rdi      # 0xcfc8
leaq 0x63a2(%rip), %rsi      # 0x909b
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq 0xa2bb(%rip), %rdi      # 0xcfc8
leaq 0x63a7(%rip), %rsi      # 0x90bb
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq 0xa2a0(%rip), %rdi      # 0xcfc8
leaq 0x63bb(%rip), %rsi      # 0x90ea
callq 0x21d0
movq %rax, %rdi
callq 0x2120
xorl %edi, %edi
callq 0x2230
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x2d57
jmp 0x2d54
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2260
movq %r15, %rdi
callq 0x69bc
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2110
testl %ebp, %ebp
jne 0x6975
leaq 0x6be4(%rip), %rdi      # 0xd538
movq %r14, %rsi
callq 0x6ad0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x664c(%rip), %rdi      # 0xcfc8
leaq 0x26b1(%rip), %rsi      # 0x9034
callq 0x21d0
leaq 0x2a36(%rip), %rsi      # 0x93c5
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
pushq $0x1
popq %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b71(%rip), %rdi      # 0xd538
movq %rbx, %rsi
callq 0x6ad0
leaq 0x2a0a(%rip), %rsi      # 0x93e0
movq %rax, %rdi
callq 0x2e1b
testb %al, %al
je 0x69e7
pushq $0x2
popq %rax
jmp 0x6a08
leaq 0x6b4a(%rip), %rdi      # 0xd538
movq %rbx, %rsi
callq 0x6ad0
leaq 0x2795(%rip), %rsi      # 0x9192
movq %rax, %rdi
callq 0x2e1b
movzbl %al, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
pushq $0x4
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2200
leaq 0x25f8(%rip), %rsi      # 0x902b
movq %r15, %rdi
callq 0x2e1b
movl %eax, %ebp
movq %r15, %rdi
callq 0x2110
testb %bpl, %bpl
je 0x6a8f
leaq 0x8(%rsp), %r15
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2200
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x708f
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x2110
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x6aa2(%rip), %rdi      # 0xd538
movq %r14, %rsi
callq 0x6ad0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x21dc(%rip), %rsi      # 0x9192
leaq 0xf(%rsp), %rdx
callq 0x2d6a
addb $-0x28, %bpl
cmpb $0x8, %bpl
jae 0x6fee
movzbl %bpl, %eax
movl $0xaf, %ecx
btl %eax, %ecx
jae 0x6fee
leaq 0x2461(%rip), %rcx      # 0x9440
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x211c(%rip), %rsi      # 0x9134
callq 0x2e1b
testb %al, %al
jne 0x706d
leaq 0x210e(%rip), %rsi      # 0x9136
movq %rbx, %rdi
callq 0x2e1b
testb %al, %al
jne 0x706d
leaq 0x20fd(%rip), %rsi      # 0x9138
movq %rbx, %rdi
callq 0x2e1b
testb %al, %al
jne 0x706d
leaq 0x20ec(%rip), %rsi      # 0x913a
movq %rbx, %rdi
callq 0x2e1b
testb %al, %al
jne 0x706d
leaq 0x212a(%rip), %rsi      # 0x918b
movq %rbx, %rdi
callq 0x2e1b
testb %al, %al
je 0x7071
xorl %eax, %eax
popq %rbx
retq
leaq 0x2021(%rip), %rsi      # 0x9099
movq %rbx, %rdi
callq 0x2e1b
xorb $0x1, %al
jmp 0x706f
// File: /workspace/github_cpp_makefile_star2_O2/reedoolang[P]reedoo/io.cc
// Function: doPRINT(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void doPRINT(string toPrint) {
  if (toPrint.substr(0,6) == "string") {
    toPrint = toPrint.substr (7);
    toPrint = toPrint.substr(1,toPrint.size() - 2);
  } else if (toPrint.substr(0,3) == "num") {
    toPrint = toPrint.substr (4);
  } else if (toPrint.substr(0,4) == "expr") {
    toPrint = toPrint.substr (5);
    toPrint = rdo_eval(toPrint);
  }
  cout << toPrint << endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x6
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2200
leaq 0x7cd(%rip), %rsi       # 0x900a
movq %r14, %rdi
callq 0x2e1b
movl %eax, %ebp
movq %r14, %rdi
callq 0x2110
movq %rsp, %r14
testb %bpl, %bpl
je 0x888b
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2110
movq 0x8(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r14
pushq $0x1
popq %rdx
jmp 0x88c2
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2200
leaq 0x785(%rip), %rsi       # 0x9027
movq %r14, %rdi
callq 0x2e1b
movl %eax, %ebp
movq %r14, %rdi
callq 0x2110
movq %rsp, %r14
testb %bpl, %bpl
je 0x8900
pushq $0x4
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2110
movq 0x46e1(%rip), %rdi      # 0xcfc8
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x4
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2200
leaq 0x714(%rip), %rsi       # 0x902b
movq %r14, %rdi
callq 0x2e1b
movl %eax, %ebp
movq %r14, %rdi
callq 0x2110
testb %bpl, %bpl
je 0x88e0
movq %rsp, %r14
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2110
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2260
movq %rsp, %rdi
movq %r14, %rsi
callq 0x708f
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2110
leaq 0x20(%rsp), %rdi
jmp 0x88db
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x22f0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq $0x2f
popq %rcx
subq %rdi, %rcx
xorl %eax, %eax
pushq $0x1
popq %rdx
movabsq $0xffffffffffff, %r8    # imm = 0xFFFFFFFFFFFF
cmpq %rsi, %rdi
jg 0x381a
movq %rdx, %r9
shlq %cl, %r9
andq %r8, %r9
orq %r9, %rax
incq %rdi
decq %rcx
jmp 0x3801
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3857
cmpl $0x68, %ecx
je 0x3857
cmpl $0x7f, %ecx
jne 0x387f
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 0x1f74a(%rip), %rax     # 0x22fd0
movq (%rax), %rcx
leaq 0x1622a(%rip), %rdi     # 0x19aba
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x3470
movq (%r14), %rax
jmp 0x3857
// File: /workspace/github_cpp_makefile_star2_O2/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, %rcx
addq $0x7, %rcx
shrq $0x3, %rcx
movq 0x1f953(%rip), %rdx     # 0x23270
leaq (%rdx,%rcx), %rax
cmpq $0x8001, %rax           # imm = 0x8001
jae 0x393c
movq %rax, 0x1f940(%rip)     # 0x23270
leaq 0x1fe89(%rip), %rax     # 0x237c0
leaq (%rax,%rdx,8), %rax
retq
pushq %rax
movq 0x1f68c(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0x1617e(%rip), %rsi     # 0x19acc
xorl %eax, %eax
callq 0x3330
pushq $0x8
popq %rdi
callq 0x3110
movq 0x1f65c(%rip), %rcx     # 0x22fc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1f656(%rip), %rsi     # 0x22fc8
movq 0x1f62f(%rip), %rdx     # 0x22fa8
movq %rax, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rcx
leaq 0x1fe35(%rip), %rsi     # 0x237c0
movq %rdi, %rax
movq 0x1f8db(%rip), %rdx     # 0x23270
leaq (%rsi,%rdx,8), %rdx
subq %rsi, %rax
jb 0x39af
cmpq %rcx, %rdx
jb 0x39af
sarq $0x3, %rax
movq %rax, 0x1f8c2(%rip)     # 0x23270
retq
pushq %rax
movq 0x1f619(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0x16138(%rip), %rsi     # 0x19af9
xorl %eax, %eax
callq 0x3330
pushq $0x1
popq %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39dc
xorl %eax, %eax
retq
movq %rdi, %rdx
movq 0x1f88a(%rip), %rcx     # 0x23270
testq %rdi, %rdi
js 0x39fc
cmpq %rdx, %rcx
jle 0x39fc
leaq 0x1fdc9(%rip), %rax     # 0x237c0
leaq (%rax,%rdx,8), %rax
retq
pushq %rax
movq 0x1f5cc(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0x16108(%rip), %rsi     # 0x19b16
xorl %eax, %eax
callq 0x3330
pushq $0x1
popq %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a5f
movq %rdi, %rax
movq 0x1f844(%rip), %rcx     # 0x23270
cmpq %rdi, %rcx
setg %dl
cmpq $0x65, %rdi
setl %sil
orb %dl, %sil
jne 0x3a5e
leaq 0x1fd7a(%rip), %rsi     # 0x237c0
movq %rax, %rdx
leaq (%rsi,%rcx,8), %r8
subq %rsi, %rdx
jb 0x3a65
cmpq %rax, %r8
jbe 0x3a65
sarq $0x3, %rdx
movq %rdx, %rax
retq
movl $0x7800, %eax           # imm = 0x7800
retq
pushq %rax
movq 0x1f563(%rip), %rcx     # 0x22fd0
movq (%rcx), %rdi
leaq 0x160cd(%rip), %rsi     # 0x19b44
leaq 0x1fd42(%rip), %rcx     # 0x237c0
movq %rax, %rdx
xorl %eax, %eax
callq 0x3330
pushq $0x1
popq %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x28
popq %r15
movabsq $0xffffffffffff, %r12   # imm = 0xFFFFFFFFFFFF
cmpq $-0x8, %r15
je 0x3adf
movq (%r14), %rax
andq %r12, %rax
movl %r15d, %ecx
shrq %cl, %rax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31e0
addq $-0x8, %r15
jmp 0x3abc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3498
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x2a
popq %r15
pushq $0x2a
popq %rbp
cmpq $-0x6, %r15
je 0x4827
movq %r14, %rax
movl %r15d, %ecx
sarq %cl, %rax
andl $0x3f, %eax
je 0x47f1
leal -0x10(%rax), %ecx
cmpl $0x9, %ecx
ja 0x47f5
orb $0x20, %al
jmp 0x4816
movb $0x20, %al
jmp 0x4816
leal -0x21(%rax), %ecx
cmpl $0x19, %ecx
ja 0x4801
addb $0x20, %al
jmp 0x4816
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 0x31e0
addq $-0x6, %r15
jmp 0x47d1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3498
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %esi, %edx
movb $0x0, 0x10(%rdi)
leal -0x7f(%rdx), %eax
cmpl $-0x60, %eax
ja 0x4895
leaq 0x1538d(%rip), %rsi     # 0x19bfd
movq %rsp, %rdi
xorl %eax, %eax
callq 0x30b0
testl %eax, %eax
js 0x48ab
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x3460
movq (%rsp), %rdi
callq 0x32d0
jmp 0x48a0
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x33d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x15351(%rip), %rdi     # 0x19c03
callq 0x31d0
jmp 0x48a0
jmp 0x48bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x3498
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: Bitset::p[abi:cxx11]() const
std::string Bitset::p() const
{
    std::ostringstream ostr;
    ostr <<'[';
    Bitset t = *this;
    int64_t start = minel(t);
    int64_t prev = start;
    t = t - Bits(start);
    while (t != Bits()) {
        int64_t m = minel(t);
        if (m != prev + 1) {
            if (ostr.str().size() != 1) ostr << ',';
            ostr << start;
            if (start != prev)
                ostr << (prev-start == 1 ? "," : "..") << prev;
            start = m;
        }
        prev = m;
        t = t - Bits(m);
    }
    if (ostr.str().size() != 1) ostr << ',';
    if (start >= 0) {
        ostr << start;
        if (start != prev)
            ostr << (prev-start == 1 ? "," : "..") << prev;
    }
    ostr << ']';
    return ostr.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, (%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3310
pushq $0x5b
popq %rsi
movq %r14, %rdi
callq 0x32b0
movabsq $0xffffffffffff, %r14   # imm = 0xFFFFFFFFFFFF
movq (%rbx), %rbp
movq %rbp, %rdi
callq 0x5593
movq %rax, %r12
movb $0x2f, %al
subb %r12b, %al
btrq %rax, %rbp
andq %r14, %rbp
leaq 0x10(%rsp), %rbx
leaq 0x30(%rsp), %r14
movq %r12, %r13
testq %rbp, %rbp
je 0x49df
movq %rbp, %rdi
callq 0x5593
movq %rax, %r15
leaq 0x1(%r12), %rax
cmpq %rax, %r15
je 0x49c1
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3380
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3498
cmpq $0x1, 0x8(%rsp)
je 0x497f
movq %r14, %rdi
pushq $0x2c
popq %rsi
callq 0x32b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x3210
movq %r12, %rax
subq %r13, %rax
movq %r15, %r13
je 0x49c1
cmpq $0x1, %rax
leaq 0x15209(%rip), %rsi     # 0x19ba9
leaq 0x158da(%rip), %rax     # 0x1a281
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x3220
movq %rax, %rdi
movq %r12, %rsi
callq 0x3210
movq %r15, %r13
movb $0x2f, %al
subb %r15b, %al
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
btrq %rax, %rcx
andq %rcx, %rbp
movq %r15, %r12
jmp 0x492f
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3380
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rbx
callq 0x3498
cmpq $0x1, %rbx
movq (%rsp), %rbx
je 0x4a13
leaq 0x30(%rsp), %rdi
pushq $0x2c
popq %rsi
callq 0x32b0
testq %r13, %r13
js 0x4a58
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x3210
movq %r12, %rax
subq %r13, %rax
je 0x4a58
cmpq $0x1, %rax
leaq 0x15171(%rip), %rsi     # 0x19ba9
leaq 0x15842(%rip), %rax     # 0x1a281
cmoveq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3220
movq %rax, %rdi
movq %r12, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
pushq $0x5d
popq %rsi
callq 0x32b0
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3380
leaq 0x30(%rsp), %rdi
callq 0x3070
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a99
jmp 0x4a99
jmp 0x4a99
jmp 0x4a99
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3320
cmpq $0xc8, %rbx
jl 0x4cba
leaq 0x155d0(%rip), %rdi     # 0x1a261
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
addq $-0x4e, %rbx
cmpq $0x8, %rbx
ja 0x4d43
movl $0x103, %eax            # imm = 0x103
btq %rbx, %rax
jae 0x4d43
popq %rbx
retq
cmpq $0x59, %rbx
jl 0x4cfd
pushq $0x56
popq %rdi
callq 0x4c75
movq %rbx, %rdi
callq 0x4aae
leaq 0x155a2(%rip), %rdi     # 0x1a279
movq %rax, %rsi
xorl %eax, %eax
callq 0x3030
cmpq $0x16, %rbx
je 0x4d2e
cmpq $0x11, %rbx
jne 0x4c9b
movq 0x5ec74(%rip), %rsi     # 0x63968
leaq 0x15575(%rip), %rdi     # 0x1a270
jmp 0x4d3c
cmpq $0x14, %rbx
jne 0x4d4c
xorl %eax, %eax
cmpl $0x0, 0x5eb10(%rip)     # 0x6381c
sete %al
leaq 0x1(,%rax,2), %rbx
movq %rbx, %rdi
callq 0x4aae
leaq 0x15553(%rip), %rdi     # 0x1a279
movq %rax, %rsi
jmp 0x4c94
movq 0x5ebab(%rip), %rsi     # 0x638e0
leaq 0x15541(%rip), %rdi     # 0x1a27d
xorl %eax, %eax
callq 0x3030
pushq $0xa
popq %rdi
popq %rbx
jmp 0x3320
leaq -0x10(%rbx), %rax
cmpq $0x2, %rax
ja 0x4cc8
movq 0x5ecc7(%rip), %rsi     # 0x63a28
shlq $0x17, %rsi
sarq $0x17, %rsi
leaq 0x15504(%rip), %rdi     # 0x1a274
xorl %eax, %eax
callq 0x3030
jmp 0x4cc8