LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: riyadparvez[P]louvain-method/main_convert.cpp
// Function: parse_args(int, char**)
void
parse_args(int argc, char **argv) {
  for (int i = 1; i < argc; i++) {
    if(argv[i][0] == '-') {
      switch(argv[i][1]) {
      case 'i':
	if (i==argc-1)
	  usage(argv[0], "Infile missing\n");
	infile = argv[i+1];
	i++;
	break;
      case 'o':
	if (i==argc-1)
	  usage(argv[0], "Outfile missing\n");
        outfile = argv[i+1];
	i++;
	break;
      case 'w' :
	type = WEIGHTED;
        outfile_w = argv[i+1];
	i++;
	break;
      case 'r' :
	do_renumber=true;
	break;
      default:
	usage(argv[0], "Unknown option\n");
      }
    } else {
      usage(argv[0], "More than one filename\n");
    }
  }
  if (infile==NULL || outfile==NULL)
    usage(argv[0], "In or outfile missing\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xc007
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xbfe4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
addl $-0x69, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0xbfcf
movq -0x20(%rbp), %rax
leaq 0x1171(%rip), %rcx      # 0xd078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xbf30
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x12aa(%rip), %rsi      # 0xd1d5
callq 0xbda0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8228(%rip)      # 0x14170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbfe2
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xbf76
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1274(%rip), %rsi      # 0xd1e5
callq 0xbda0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x81ea(%rip)      # 0x14178
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbfe2
movl $0x0, 0x81b5(%rip)      # 0x14158
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x81c5(%rip)      # 0x14180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbfe2
movb $0x1, 0x81bb(%rip)      # 0x14188
jmp 0xbfe2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1219(%rip), %rsi      # 0xd1f6
callq 0xbda0
jmp 0xbff7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1214(%rip), %rsi      # 0xd206
callq 0xbda0
jmp 0xbff9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbeb6
cmpq $0x0, 0x8161(%rip)      # 0x14170
je 0xc01b
cmpq $0x0, 0x815f(%rip)      # 0x14178
jne 0xc02e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x11f5(%rip), %rsi      # 0xd21e
callq 0xbda0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: riyadparvez[P]louvain-method/main_convert.cpp
// Function: main
int
main(int argc, char **argv) {
  parse_args(argc, argv);

  Graph g(infile, type);

  g.clean(type);

  if (do_renumber)
    g.renumber(type);

  g.display_binary(outfile, outfile_w, type);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xbea0
movq 0x8107(%rip), %rsi      # 0x14170
movl 0x80e9(%rip), %edx      # 0x14158
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2400
movq -0x58(%rbp), %rdi
movl 0x80d2(%rip), %esi      # 0x14158
callq 0x2de0
jmp 0xc08d
testb $0x1, 0x80f4(%rip)      # 0x14188
je 0xc0c0
movl 0x80bc(%rip), %esi      # 0x14158
leaq -0x40(%rbp), %rdi
callq 0x2950
jmp 0xc0a7
jmp 0xc0c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc100
jmp 0xc0f1
movq 0x80b1(%rip), %rsi      # 0x14178
movq 0x80b2(%rip), %rdx      # 0x14180
movl 0x8084(%rip), %ecx      # 0x14158
leaq -0x40(%rbp), %rdi
callq 0x32a0
jmp 0xc0df
leaq -0x40(%rbp), %rdi
callq 0xc100
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2260
nopw (%rax,%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: getVariables(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
stringVector getVariables(const stringVector& tokenVector) {
    stringVector variableVector;
    for(stringIter i = tokenVector.begin(); i != tokenVector.end(); ++i) {

        if(i->length() == 1 && isalpha(i->at(0)) && i->at(0) != 'v' &&
                                 i->at(0) != 'c' && i->at(0) != 't') {

            if(!(std::find(variableVector.begin(), variableVector.end(), *i) !=
                    variableVector.end())) {
                variableVector.push_back(*i);
            }
        }
    }

    return variableVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4d90
movq -0x10(%rbp), %rdi
callq 0x52a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5310
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x52d0
testb $0x1, %al
jne 0x3387
jmp 0x3504
leaq -0x20(%rbp), %rdi
callq 0x5340
movq %rax, %rdi
callq 0x2270
cmpq $0x1, %rax
jne 0x34f4
leaq -0x20(%rbp), %rdi
callq 0x5340
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq %rax, -0x70(%rbp)
jmp 0x33bd
movq -0x70(%rbp), %rax
movsbl (%rax), %edi
callq 0x2290
cmpl $0x0, %eax
je 0x34f4
leaq -0x20(%rbp), %rdi
callq 0x5340
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq %rax, -0x78(%rbp)
jmp 0x33ed
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x76, %eax
je 0x34f4
leaq -0x20(%rbp), %rdi
callq 0x5340
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq %rax, -0x80(%rbp)
jmp 0x3418
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x63, %eax
je 0x34f4
leaq -0x20(%rbp), %rdi
callq 0x5340
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq %rax, -0x88(%rbp)
jmp 0x3446
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
je 0x34f4
movq -0x68(%rbp), %rdi
callq 0x4f60
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x5010
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5040
movq %rax, %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x53a0
movq %rax, -0x90(%rbp)
jmp 0x3495
movq -0x68(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x5010
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5360
xorb $-0x1, %al
testb $0x1, %al
jne 0x34c2
jmp 0x34f2
leaq -0x20(%rbp), %rdi
callq 0x5040
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x51a0
jmp 0x34d9
jmp 0x34f2
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4e00
jmp 0x3524
jmp 0x34f4
jmp 0x34f6
leaq -0x20(%rbp), %rdi
callq 0x5060
jmp 0x3364
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3517
movq -0x68(%rbp), %rdi
callq 0x4e00
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: combineVectors(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
stringVector combineVectors(const stringVector& vector1, 
                            const stringVector& vector2) {
    stringVector newVector = vector1;

    for(stringIter i = vector2.begin(); i != vector2.end(); ++i) {
        if(std::find(newVector.begin(), 
                     newVector.end(), *i) == newVector.end()) {
            newVector.push_back(*i);
        }
    }

    std::sort(newVector.begin(), newVector.end());

    return newVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5790
movq -0x18(%rbp), %rdi
callq 0x52a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5310
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x52d0
testb $0x1, %al
jne 0x358f
jmp 0x3636
movq -0x80(%rbp), %rdi
callq 0x4f60
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x5010
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5040
movq %rax, %rdx
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x53a0
movq %rax, -0x88(%rbp)
jmp 0x35cb
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x5010
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5880
testb $0x1, %al
jne 0x35f6
jmp 0x3626
leaq -0x28(%rbp), %rdi
callq 0x5040
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x51a0
jmp 0x360d
jmp 0x3626
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4e00
jmp 0x367f
jmp 0x3628
leaq -0x28(%rbp), %rdi
callq 0x5060
jmp 0x356c
movq -0x80(%rbp), %rdi
callq 0x4f60
movq -0x80(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x5010
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x58c0
jmp 0x365f
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3672
movq -0x80(%rbp), %rdi
callq 0x4e00
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22c0
nopl (%rax,%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: setValues(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int)
void setValues(boolMap& bmap, const stringVector& variableVector, 
                                                  int comboGen) {
    int j = 0;
    for(stringIter i = variableVector.begin(); i != variableVector.end(); i++) {
        if((comboGen >> j) & 0x01) {
            bmap[*i] = true;
        }

        else {
            bmap[*i] = false;
        }
        j++;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5310
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x52d0
testb $0x1, %al
jne 0x3b47
jmp 0x3bb6
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3b79
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5040
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5670
movb $0x1, (%rax)
jmp 0x3b99
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5040
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5670
movb $0x0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5750
movq %rax, -0x30(%rbp)
jmp 0x3b27
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: printBool(bool)
void printBool(bool b) {
    if(b) {
        std::cout << "T";
    }

    else {
        std::cout << "F";
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0x425b
movq 0xdd83(%rip), %rdi      # 0x11fd0
leaq 0x7f4e(%rip), %rsi      # 0xc1a2
callq 0x2190
jmp 0x426e
movq 0xdd6e(%rip), %rdi      # 0x11fd0
leaq 0x7f3b(%rip), %rsi      # 0xc1a4
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: isOperator(char const&)
bool isOperator(const char& ch) {
    char validOperators[] = {'!', 'v', '^'};

    for(int i = 0; i < 3; i++) {
        if(ch == validOperators[i]) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movw 0x7f29(%rip), %ax       # 0xc1f8
movw %ax, -0x13(%rbp)
movb 0x7f21(%rip), %al       # 0xc1fa
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x4310
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x18(%rbp), %rcx
movsbl -0x13(%rbp,%rcx), %ecx
cmpl %ecx, %eax
jne 0x4303
movb $0x1, -0x1(%rbp)
jmp 0x4314
jmp 0x4305
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x42e3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mbottini[P]CS250lab2/main.cpp
// Function: getPrecedence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int getPrecedence(const string& s) {
    if(s == "<->") {
        return 0;
    }

    if(s == "->") {
        return 1;
    }

    if(s == "XOR") {
        return 2;
    }

    if(s == "v") {
        return 3;
    }

    if(s == "^") {
        return 4;
    }

    if(s == "!") {
        return 5;
    }

    else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x784b(%rip), %rsi      # 0xc0b2
callq 0x5140
testb $0x1, %al
jne 0x4872
jmp 0x487e
movl $0x0, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
leaq 0x782a(%rip), %rsi      # 0xc0b3
callq 0x5140
testb $0x1, %al
jne 0x4894
jmp 0x48a0
movl $0x1, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
leaq 0x7803(%rip), %rsi      # 0xc0ae
callq 0x5140
testb $0x1, %al
jne 0x48b6
jmp 0x48bf
movl $0x2, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
leaq 0x77ec(%rip), %rsi      # 0xc0b6
callq 0x5140
testb $0x1, %al
jne 0x48d5
jmp 0x48de
movl $0x3, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
leaq 0x77cf(%rip), %rsi      # 0xc0b8
callq 0x5140
testb $0x1, %al
jne 0x48f4
jmp 0x48fd
movl $0x4, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
leaq 0x7734(%rip), %rsi      # 0xc03c
callq 0x5140
testb $0x1, %al
jne 0x4913
jmp 0x491c
movl $0x5, -0x4(%rbp)
jmp 0x4923
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: davmac314[P]dinit/build/tools/mconfig-gen.cc
// Function: parse_arg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void parse_arg(std::string arg)
{
    auto idx = arg.find("=", 0, 1);
    if (idx == std::string::npos) {
        throw std::string("Couldn't parse argument: ") + arg;
    }

    auto name = arg.substr(0, idx);
    auto value = arg.substr(idx + 1);
    vars.emplace(std::move(name), std::move(value));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x4b3b(%rip), %rsi      # 0x7008
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x22a0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x25a9
movb $0x1, -0x45(%rbp)
movl $0x20, %edi
callq 0x20b0
movq %rax, -0xb0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x22c0
movq -0xa8(%rbp), %rdx
leaq 0x4aed(%rip), %rsi      # 0x700a
leaq -0x30(%rbp), %rdi
callq 0x3ff0
jmp 0x2528
movq -0xa0(%rbp), %rdx
movq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3fa0
jmp 0x2541
movq -0xb0(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x884d(%rip), %rsi      # 0xada0
movq 0x8a6e(%rip), %rdx      # 0xafc8
callq 0x2290
jmp 0x267a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2587
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2318
leaq -0x31(%rbp), %rdi
callq 0x21e0
testb $0x1, -0x45(%rbp)
jne 0x2598
jmp 0x25a4
movq -0xb0(%rbp), %rdi
callq 0x2120
jmp 0x2671
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x21c0
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdx
incq %rdx
leaq -0x88(%rbp), %rdi
movq $-0x1, %rcx
callq 0x21c0
jmp 0x25e4
leaq 0x8bc5(%rip), %rdi      # 0xb1b0
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x40a0
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x260a
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2318
leaq -0x68(%rbp), %rdi
callq 0x2318
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2668
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2318
leaq -0x68(%rbp), %rdi
callq 0x2318
movq -0x40(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: davmac314[P]dinit/build/tools/mconfig-gen.cc
// Function: stringify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string stringify(std::string a)
{
    std::string out = "\"";

    for (std::string::size_type i = 0; i < a.length(); i++) {
        char c = a[i];
        if (c == '\n') out += "\\n";
        else if (c == '\t') out += "\\t";
        else if (c == '\"') out += "\\\"";
        else if (c < 0x20) {
            out += "\\x" ;
            out += to_hex_digit((c & 0xF0) >> 4);
            out += to_hex_digit((c & 0x0F));
        }
        else out += c;
    }

    out += "\"";
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x22c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x361c(%rip), %rsi      # 0x73db
callq 0x3ff0
jmp 0x3dc6
leaq -0x12(%rbp), %rdi
callq 0x21e0
movq $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x2260
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f20
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2300
movq %rax, -0x68(%rbp)
jmp 0x3e0b
movq -0x68(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
jne 0x3e68
movq -0x48(%rbp), %rdi
leaq 0x35ac(%rip), %rsi      # 0x73d4
callq 0x2180
jmp 0x3e2f
jmp 0x3f0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x21e0
jmp 0x3f4f
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2318
jmp 0x3f4f
movsbl -0x31(%rbp), %eax
cmpl $0x9, %eax
jne 0x3e88
movq -0x48(%rbp), %rdi
leaq 0x355b(%rip), %rsi      # 0x73d7
callq 0x2180
jmp 0x3e83
jmp 0x3f0b
movsbl -0x31(%rbp), %eax
cmpl $0x22, %eax
jne 0x3ea5
movq -0x48(%rbp), %rdi
leaq 0x353e(%rip), %rsi      # 0x73da
callq 0x2180
jmp 0x3ea3
jmp 0x3f09
movsbl -0x31(%rbp), %eax
cmpl $0x20, %eax
jge 0x3ef6
movq -0x48(%rbp), %rdi
leaq 0x3524(%rip), %rsi      # 0x73dd
callq 0x2180
jmp 0x3ec0
movzbl -0x31(%rbp), %edi
shrl $0x4, %edi
callq 0x2480
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0x20e0
jmp 0x3eda
movzbl -0x31(%rbp), %edi
andl $0xf, %edi
callq 0x2480
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0x20e0
jmp 0x3ef4
jmp 0x3f07
movq -0x48(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x20e0
jmp 0x3f05
jmp 0x3f07
jmp 0x3f09
jmp 0x3f0b
jmp 0x3f0d
jmp 0x3f0f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3dd7
movq -0x48(%rbp), %rdi
leaq 0x34b0(%rip), %rsi      # 0x73db
callq 0x2180
jmp 0x3f32
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3f45
movq -0x48(%rbp), %rdi
callq 0x2318
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: shengzh-oOoO[P]CodeSim/src/text_moss.cpp
// Function: CodeFile::CreateHashList()
void CreateHashList(){
        FILE *fid = fopen(filename,"r");
        if(fid == NULL){
            printf("打开%s失败\n",filename);
            assert(false);
        }
        char ch = 0;
        char prev_ch = 0;
        while(EOF!=(ch= fgetc(fid))){
        	if (ch=='\n'||ch=='\t'){
        		ch = ' ';
        	}
        	if(prev_ch == ' '&& ch ==' '){
        		continue;
        	}
            if (hashwindow.size() < N_GRAM_K){
                hashwindow.push_back(ch);    
            }
            else{
                hashlist.push_back(RSHash());
                hashwindow.pop_front();
                hashwindow.push_back(ch);
            }
            prev_ch = ch;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x38b0(%rip), %rsi      # 0x507b
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x180c
movq -0x28(%rbp), %rsi
leaq 0x3897(%rip), %rdi      # 0x507d
movb $0x0, %al
callq 0x1030
leaq 0x3844(%rip), %rdi      # 0x5038
leaq 0x3843(%rip), %rsi      # 0x503e
movl $0x2b, %edx
leaq 0x3886(%rip), %rcx      # 0x508d
callq 0x1090
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1120
movb %al, -0x11(%rbp)
movsbl %al, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x18d0
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x1842
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x1846
movb $0x20, -0x11(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x20, %eax
jne 0x185a
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x185a
jmp 0x1814
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x1da0
cmpq $0xa, %rax
jae 0x1880
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
leaq -0x11(%rbp), %rsi
callq 0x1dd0
jmp 0x18c5
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
callq 0x1e40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x1e10
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x1f40
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
leaq -0x11(%rbp), %rsi
callq 0x1dd0
movb -0x11(%rbp), %al
movb %al, -0x12(%rbp)
jmp 0x1814
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shengzh-oOoO[P]CodeSim/src/text_moss.cpp
// Function: CodeFile::Winnowing()
void Winnowing(){
        list<long> win;
        vector<long>::iterator h;
        long before = LONG_LONG_MAX;
        for (h = hashlist.begin(); h != hashlist.end(); h++){
            if (win.size() < WINNOWING_SIZE){
                win.push_back(*h);
            }
            else{
                list<long>::iterator i;
                long min = LONG_LONG_MAX;
                for (i = win.begin(); i != win.end(); i++){
                    if(*i < min) min = *i;
                }
                if(min !=  before){
                    before = min;
                    result.push_back(min);
                }
                win.pop_front();
                win.push_back(*h);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2e40
leaq -0x28(%rbp), %rdi
callq 0x2e60
movq -0x88(%rbp), %rdi
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
addq $0x80, %rdi
callq 0x1b00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rdi
addq $0x80, %rdi
callq 0x1b30
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e80
testb $0x1, %al
jne 0x1966
jmp 0x1a9b
leaq -0x20(%rbp), %rdi
callq 0x2ec0
cmpq $0x5, %rax
jae 0x19ab
leaq -0x28(%rbp), %rdi
callq 0x2c00
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2ef0
jmp 0x198c
jmp 0x1a85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3110
jmp 0x1aad
leaq -0x58(%rbp), %rdi
callq 0x2f30
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2f50
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2fb0
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2f80
testb $0x1, %al
jne 0x19f7
jmp 0x1a2c
leaq -0x58(%rbp), %rdi
callq 0x2fe0
movq (%rax), %rax
cmpq -0x60(%rbp), %rax
jge 0x1a19
leaq -0x58(%rbp), %rdi
callq 0x2fe0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x1a1b
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x3000
movq %rax, -0x78(%rbp)
jmp 0x19d7
movq -0x60(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x1a59
movq -0x88(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x98, %rdi
leaq -0x60(%rbp), %rsi
callq 0x3030
jmp 0x1a57
jmp 0x1a59
leaq -0x20(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x30a0
leaq -0x28(%rbp), %rdi
callq 0x2c00
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x2ef0
jmp 0x1a83
jmp 0x1a85
jmp 0x1a87
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x30d0
movq %rax, -0x80(%rbp)
jmp 0x1939
leaq -0x20(%rbp), %rdi
callq 0x3110
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
// File: shengzh-oOoO[P]CodeSim/src/text_moss.cpp
// Function: CodeFile::RSHash()
long RSHash(){
        long b = 378551;
        long a = 63689;
        long hash = 0;
        assert(hashwindow.size() == N_GRAM_K);
        list<char>::iterator i;
        for (i = hashwindow.begin(); i != hashwindow.end(); i++){
        	// printf("%c", (*i));
            hash = hash * a + (long) (*i);
            a = a * b;
        }
        // printf("\n");
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x5c6b7, -0x10(%rbp)   # imm = 0x5C6B7
movq $0xf8c9, -0x18(%rbp)    # imm = 0xF8C9
movq $0x0, -0x20(%rbp)
addq $0x68, %rdi
callq 0x1da0
cmpq $0xa, %rax
jne 0x1e7d
jmp 0x1e9c
leaq 0x3243(%rip), %rdi      # 0x50c7
leaq 0x31b3(%rip), %rsi      # 0x503e
movl $0x18, %edx
leaq 0x324e(%rip), %rcx      # 0x50e5
callq 0x1090
leaq -0x28(%rbp), %rdi
callq 0x2c40
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x2c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x2010
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2c90
testb $0x1, %al
jne 0x1ee2
jmp 0x1f28
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2cc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsbq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x2ce0
movq %rax, -0x40(%rbp)
jmp 0x1ebe
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: show_reactivo(unsigned int)
int show_reactivo(unsigned int index)
{
  printf("\n/************************************************/\n");
  if((index>=0)&&(index<NUMDREAC)){
    printf("REACTIVO %u:\n",index+1);
    printf("%s\n",REACTIVO[index]);
    printf("\n/************************************************/\n");
  }else{
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x1b02(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x2030
cmpl $0x0, -0x8(%rbp)
jb 0x2558
cmpl $0x3, -0x8(%rbp)
jae 0x2558
movl -0x8(%rbp), %esi
addl $0x1, %esi
leaq 0x1b17(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x2030
movl -0x8(%rbp), %eax
leaq 0x3cad(%rip), %rsi      # 0x61e0
shlq $0xb, %rax
addq %rax, %rsi
leaq 0x1c2b(%rip), %rdi      # 0x416c
movb $0x0, %al
callq 0x2030
leaq 0x1ab5(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x2030
jmp 0x2561
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2568
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: siguiente_turno()
unsigned int siguiente_turno(){
  int candidato_a_ser_reactivo_en_turno;
  if(cantidad_de_reactivos_usados==NUMDREAC){
    modificado=false;
    return 0;
  }
  if((NUMDREAC-cantidad_de_reactivos_usados)==1){
unsigned int usar_NUMDREAC_buckets();
    if((reactivo_en_turno=usar_NUMDREAC_buckets())>0){
//printf("candidato_a_ser_reactivo_en_turno=%u\n",candidato_a_ser_reactivo_en_turno);
      goto actualizacion;
    }
  }
  if(cantidad_de_reactivos_usados<NUMDREAC){
    srand(time(NULL));
    candidato_a_ser_reactivo_en_turno=1+rand()%NUMDREAC;
bool asignado(unsigned int);
    while(asignado(candidato_a_ser_reactivo_en_turno)){
      candidato_a_ser_reactivo_en_turno=1+rand()%NUMDREAC;
    }
    reactivo_en_turno=candidato_a_ser_reactivo_en_turno;
    assert(reactivo_en_turno<=NUMDREAC);
void actualizar_reactivos_usados(unsigned int);
actualizacion:
    actualizar_reactivos_usados(reactivo_en_turno);
  }
  return reactivo_en_turno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5451(%rip), %rax      # 0x79e0
cmpl $0x3, (%rax)
jne 0x25aa
leaq 0x5455(%rip), %rax      # 0x79f0
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2682
movl $0x3, %eax
leaq 0x542a(%rip), %rcx      # 0x79e0
subl (%rcx), %eax
cmpl $0x1, %eax
jne 0x25d7
callq 0x2690
leaq 0x542b(%rip), %rcx      # 0x79f4
movl %eax, (%rcx)
cmpl $0x0, %eax
jbe 0x25d5
jmp 0x2668
jmp 0x25d7
leaq 0x5402(%rip), %rax      # 0x79e0
cmpl $0x3, (%rax)
jae 0x2676
xorl %eax, %eax
movl %eax, %edi
callq 0x2170
movl %eax, %edi
callq 0x2180
callq 0x2090
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x2720
testb $0x1, %al
jne 0x2618
jmp 0x262d
callq 0x2090
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x8(%rbp)
jmp 0x260a
movl -0x8(%rbp), %ecx
leaq 0x53bd(%rip), %rax      # 0x79f4
movl %ecx, (%rax)
leaq 0x53b4(%rip), %rax      # 0x79f4
cmpl $0x3, (%rax)
ja 0x2647
jmp 0x2666
leaq 0x19f9(%rip), %rdi      # 0x4047
leaq 0x1a0e(%rip), %rsi      # 0x4063
movl $0x43, %edx
leaq 0x1a11(%rip), %rcx      # 0x4072
callq 0x20f0
jmp 0x2668
leaq 0x5385(%rip), %rax      # 0x79f4
movl (%rax), %edi
callq 0x2770
leaq 0x5377(%rip), %rax      # 0x79f4
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: usar_NUMDREAC_buckets()
unsigned int usar_NUMDREAC_buckets()
{
  char bucket[NUMDREAC+1]={0};        /* buckets o cubetas a utilizar */
  int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    bucket[reactivos_usados[i]]=1;
  }
  for(i=1;i<NUMDREAC;i++){
    if(bucket[i]==0){
      return i;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x20d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x5327(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x26de
leaq 0x5324(%rip), %rax      # 0x79e8
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb $0x1, -0x8(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26af
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x270e
movslq -0xc(%rbp), %rax
movsbl -0x8(%rbp,%rax), %eax
cmpl $0x0, %eax
jne 0x2701
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2715
jmp 0x2703
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: asignado(unsigned int)
bool asignado(unsigned int candidato)
{
  unsigned int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    if(*(reactivos_usados+i)==candidato){
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x52a8(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x2764
leaq 0x52a5(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x2757
movb $0x1, -0x1(%rbp)
jmp 0x2768
jmp 0x2759
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x272e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: actualizar_reactivos_usados(unsigned int)
void actualizar_reactivos_usados(unsigned int reactivo_en_uso)
{
  unsigned int i,*tmp=(unsigned int *)malloc(cantidad_de_reactivos_usados*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    *(tmp+i)=reactivos_usados[i];
  }
  reactivos_usados=(unsigned int *)malloc(
                   (cantidad_de_reactivos_usados+1)*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    reactivos_usados[i]=*(tmp+i);
  }
  reactivos_usados[cantidad_de_reactivos_usados]=reactivo_en_uso;
  cantidad_de_reactivos_usados++;
  modificado=true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x525e(%rip), %rax      # 0x79e0
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2250
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x523c(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x27cd
leaq 0x5239(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x279a
leaq 0x520c(%rip), %rax      # 0x79e0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2250
movq %rax, %rcx
leaq 0x51f8(%rip), %rax      # 0x79e8
movq %rcx, (%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x51dc(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x282d
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0x51cf(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x27fa
movl -0x4(%rbp), %edx
leaq 0x51b1(%rip), %rax      # 0x79e8
movq (%rax), %rax
leaq 0x519f(%rip), %rcx      # 0x79e0
movl (%rcx), %ecx
movl %edx, (%rax,%rcx,4)
leaq 0x5193(%rip), %rax      # 0x79e0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x5187(%rip), %rax      # 0x79e0
movl %ecx, (%rax)
leaq 0x518e(%rip), %rax      # 0x79f0
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/test_EvalContinua.c
// Function: main
int main(int argc,char *argv[])
{
  unsigned int indice_de_reactivo,reactivo_index,ret;
  if(argc<2){
    printf("FORMA DE USO:%s <file_index_reactivos_intro>\n",
            argv[0]);
    exit(1);
  }
void run_ctor(char *);
  run_ctor(argv[1]);
unsigned int init_REACTIVO();
   if((ret=init_REACTIVO())==NUMDREAC){
unsigned int siguiente_turno();
     if((reactivo_index=siguiente_turno())>0){
#ifndef NDEBUG
       printf("reactivo_index=%u\n",reactivo_index);
#endif
       indice_de_reactivo=reactivo_index-1;
int show_reactivo(unsigned int);
       show_reactivo(indice_de_reactivo);
void save_reactivos_asignados(unsigned int);
       if(modificado){
         save_reactivos_asignados(reactivo_index);
       }
     }else{ 
       printf("Reactivos YA asignados ...\n");
       return 0;
     }
   }else{
#ifndef NDEBUG
     printf("ret=%u\n",ret);
#endif
     return -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x2e3b
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x12ca(%rip), %rdi      # 0x40f4
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2ec0
callq 0x31c0
movl %eax, -0x1c(%rbp)
cmpl $0x3, %eax
jne 0x2ea2
callq 0x2580
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jbe 0x2e89
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x24f0
leaq 0x4b76(%rip), %rax      # 0x79f0
testb $0x1, (%rax)
je 0x2e87
movl -0x18(%rbp), %edi
callq 0x2870
jmp 0x2ea0
leaq 0x1292(%rip), %rdi      # 0x4122
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
jmp 0x2ea9
jmp 0x2ea9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: sotrteacher[P]1MM1INTRO/20190925_1MM1_INTRO/ctors.c
// Function: init_REACTIVO()
unsigned int init_REACTIVO()
{
  unsigned int i,j=0;
  FILE *fent;
  int car,res=0;
  char nombre_de_archivo[1024];
  
  for(i=0;i<NUMDREAC;i++){
    sprintf(nombre_de_archivo,"./reactivos/reactivo%d.txt",i+1);
#ifndef NDEBUG
    printf("Abriendo %s\n",nombre_de_archivo);
#endif
    /**Apertura del i-esimo archivo de entrada*/
    fent=fopen(nombre_de_archivo,"r");
    if(fent==NULL){
      fprintf(stderr,"Error abriendo %s\n",nombre_de_archivo);
      return i;
    }
    while((car=fgetc(fent))!=EOF){
      REACTIVO[i][j++]=car;
    }
    j=0;
    /**Cierre del i-esimo archivo*/ 
    fclose(fent);
#ifndef NDEBUG
    printf("%s\n",REACTIVO[i]);
#endif
  }/*end for()*/
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl $0x0, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jae 0x32a5
leaq -0x420(%rbp), %rdi
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0xf42(%rip), %rsi       # 0x4140
movb $0x0, %al
callq 0x2050
leaq -0x420(%rbp), %rdi
leaq 0xf48(%rip), %rsi       # 0x415b
callq 0x2200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x324a
movq 0x2dae(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq -0x420(%rbp), %rdx
leaq 0xf22(%rip), %rsi       # 0x415d
movb $0x0, %al
callq 0x2290
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32ab
jmp 0x324c
movq -0x18(%rbp), %rdi
callq 0x22f0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x3287
movl -0x1c(%rbp), %eax
movb %al, %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x2f72(%rip), %rax      # 0x61e0
shlq $0xb, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x324c
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x31e0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: roberty65[P]bServer/serverd/src/main.cpp
// Function: loadProcessor(char const*)
Processor *loadProcessor(const char *lib)
{
	void *dh = dlopen(lib, RTLD_NOW);
	if (dh == NULL) {
		SYSLOG_ERROR("can not load plugin %s, error: %s", lib, dlerror());
		return NULL;
	}

	Processor *(*creator)();
	if ((creator = (Processor *(*)())dlsym(dh, "createProcessor")) == NULL) {
		SYSLOG_ERROR("plugin %s has no createProcessor defined: %s", lib, dlerror());
		dlclose(dh);
		return NULL;
	}
	
	Processor *processor = (*creator)();
	if (processor == NULL) {
		SYSLOG_ERROR("plugin %s createProcessor failed: %m", lib);
		dlclose(dh);
		return NULL;
	}

	return processor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3560
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x39f8
jmp 0x3997
leaq 0x16c4a(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x39e9
leaq 0x16c31(%rip), %rax     # 0x1a5e8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq %rax, %r8
movl $0x2, %esi
leaq 0xe672(%rip), %rdx      # 0x12054
movb $0x0, %al
callq 0xbf40
jmp 0x39eb
movq $0x0, -0x8(%rbp)
jmp 0x3ae2
movq -0x18(%rbp), %rdi
leaq 0xe673(%rip), %rsi      # 0x12076
callq 0x3390
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3a7b
jmp 0x3a14
leaq 0x16bcd(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x3a66
leaq 0x16bb4(%rip), %rax     # 0x1a5e8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x33a0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq %rax, %r8
movl $0x2, %esi
leaq 0xe627(%rip), %rdx      # 0x12086
movb $0x0, %al
callq 0xbf40
jmp 0x3a68
movq -0x18(%rbp), %rdi
callq 0x3310
movq $0x0, -0x8(%rbp)
jmp 0x3ae2
callq *-0x20(%rbp)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3ada
jmp 0x3a8b
leaq 0x16b56(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x3ac5
leaq 0x16b3d(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x2, %esi
leaq 0xe5f5(%rip), %rdx      # 0x120b3
movb $0x0, %al
callq 0xbf40
jmp 0x3ac7
movq -0x18(%rbp), %rdi
callq 0x3310
movq $0x0, -0x8(%rbp)
jmp 0x3ae2
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/frame/main/EventManager.cpp
// Function: beyondy::Async::EventManager::addListener(char const*, beyondy::Async::Queue<beyondy::Async::Message>*, beyondy::Async::Processor*, int)
int EventManager::addListener(const char *address, Queue<Message> *inQueue, Processor *processor, int maxActive)
{
	Listener *listener = new Listener(address, maxActive, this, inQueue, processor);
	if (listener == NULL) {
		SYSLOG_ERROR("open listener at %s failed", address);
		return -1;
	}
	
	if (listener->open() < 0 || this->addHandler(listener, EVENT_IN) < 0) {
		SYSLOG_ERROR("open or watch-IN failed for listener at %s", address);
		delete listener;
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0xb0, %edi
callq 0x33c0
movq -0x58(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0xb810
jmp 0x75e2
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x765c
jmp 0x75f3
leaq 0x12fee(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x764e
leaq 0x12fd5(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movl $0x2, %esi
leaq 0xae8c(%rip), %rdx      # 0x124b2
movb $0x0, %al
callq 0xbf40
jmp 0x764e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0xb0, %esi
callq 0x33d0
jmp 0x76f0
jmp 0x7650
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x76e7
movq -0x38(%rbp), %rdi
callq 0xbe30
cmpl $0x0, %eax
jl 0x7681
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x7700
cmpl $0x0, %eax
jge 0x76e0
jmp 0x7683
leaq 0x12f5e(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x76bd
leaq 0x12f45(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movl $0x2, %esi
leaq 0xae17(%rip), %rdx      # 0x124cd
movb $0x0, %al
callq 0xbf40
jmp 0x76bf
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x76d7
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x76e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3690
nopl (%rax)
// File: roberty65[P]bServer/frame/main/EventManager.cpp
// Function: beyondy::Async::EventManager::addHandler(beyondy::Async::EventHandler*, int)
int EventManager::addHandler(EventHandler *handler, int events)
{
	struct epoll_event ee;
	int retval;
	
	ee.events = events;
	ee.data.ptr = (void *)handler;
	
	retval = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, handler->fd, &ee);
	if (retval == 0) {
		handler->events = events;
		SYSLOG_DEBUG("addHandler fd=%d events=%d OK", handler->fd, events);
	}
	else {
		SYSLOG_DEBUG("addHandler fd=%d failed: %m", handler->fd);
	}

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x1c(%rbp)
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
callq 0x3550
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x7794
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0x12e92(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x5, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x7790
leaq 0x12e79(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0x14(%rbp), %r8d
movl $0x5, %esi
leaq 0xad8b(%rip), %rdx      # 0x12514
movb $0x0, %al
callq 0xbf40
jmp 0x7792
jmp 0x77d7
jmp 0x7796
leaq 0x12e4b(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x5, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x77d3
leaq 0x12e32(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x5, %esi
leaq 0xad66(%rip), %rdx      # 0x12532
movb $0x0, %al
callq 0xbf40
jmp 0x77d5
jmp 0x77d7
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: roberty65[P]bServer/frame/main/EventManager.cpp
// Function: beyondy::Async::EventManager::addConnector(char const*, beyondy::Async::Queue<beyondy::Async::Message>*, beyondy::Async::Processor*, int)
int EventManager::addConnector(const char *address, Queue<Message> *inQueue, Processor *processor, int openImmediately)
{
	int flow = nextFlow();
	Connector *connector = new Connector(flow, address, this, inQueue, processor);

	if (openImmediately && connector->open() < 0) {
		SYSLOG_ERROR("open Connector to %s failed", address);
		return -1;
	}

	mapFlow(flow, connector);
	_list_add_tail(&connector->connectorsEntry, &connectorsHead);

	return flow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7900
movl %eax, -0x30(%rbp)
movl $0x138, %edi            # imm = 0x138
callq 0x33c0
movq -0x58(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x30(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0xadc0
jmp 0x783a
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x78bb
movq -0x38(%rbp), %rdi
callq 0xb0f0
cmpl $0x0, %eax
jge 0x78bb
jmp 0x7858
leaq 0x12d89(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0x78b0
leaq 0x12d70(%rip), %rax     # 0x1a5e8
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movl $0x2, %esi
leaq 0xac6d(%rip), %rdx      # 0x124f8
movb $0x0, %al
callq 0xbf40
jmp 0x78b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x138, %esi            # imm = 0x138
callq 0x33d0
jmp 0x78f2
jmp 0x78b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78e9
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x7920
movq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
addq $0x30, %rsi
callq 0x79f0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3690
nopl (%rax,%rax)