LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sanket143[P]2048-Terminal-Game/./src/2048.cpp
// Function: main
int main(){
  gb::Board board;
  while(true){
    std::cout << "\033[2J\033[1;1H";
    std::cout << "2048 Terminal Game" << std::endl;
    std::cout << "Valid Directions: [R|D|L|U]" << std::endl;
    std::string input;

    board.display();

    std::cout << "Direction: ";
    std::cin >> input;

    if(!board.valid(input)){
      continue;
    }
    std::cout << "Loading..." << std::endl;
    board.move(input);
    board.add_tile();
    board.display();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2630
movq 0x5b9e(%rip), %rdi      # 0x7fd0
movq %rdi, -0xd0(%rbp)
leaq 0x2bc4(%rip), %rsi      # 0x5004
callq 0x2170
movq -0xd0(%rbp), %rdi
leaq 0x2bbc(%rip), %rsi      # 0x500f
callq 0x2170
movq %rax, %rdi
movq 0x5b5e(%rip), %rsi      # 0x7fc0
movq %rsi, -0xc8(%rbp)
callq 0x21a0
movq -0xd0(%rbp), %rdi
leaq 0x2ba6(%rip), %rsi      # 0x5022
callq 0x2170
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x21a0
leaq -0x68(%rbp), %rdi
callq 0x2230
leaq -0x48(%rbp), %rdi
callq 0x26a0
jmp 0x24a4
movq 0x5b25(%rip), %rdi      # 0x7fd0
leaq 0x2b8c(%rip), %rsi      # 0x503e
callq 0x2170
jmp 0x24b9
movq 0x5b20(%rip), %rdi      # 0x7fe0
leaq -0x68(%rbp), %rsi
callq 0x2210
jmp 0x24cb
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20a0
jmp 0x24dd
leaq -0x48(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2890
movb %al, -0xd1(%rbp)
jmp 0x24f5
movb -0xd1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xd2(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20f0
movb -0xd2(%rbp), %al
testb $0x1, %al
jne 0x251b
jmp 0x2558
movl $0x2, -0x9c(%rbp)
jmp 0x25d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20f0
jmp 0x2610
movq 0x5a71(%rip), %rdi      # 0x7fd0
leaq 0x2ae4(%rip), %rsi      # 0x504a
callq 0x2170
movq %rax, -0xe0(%rbp)
jmp 0x2574
movq -0xe0(%rbp), %rdi
movq 0x5a3e(%rip), %rsi      # 0x7fc0
callq 0x21a0
jmp 0x2589
leaq -0xc0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20a0
jmp 0x259b
leaq -0x48(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2bb0
jmp 0x25ad
leaq -0xc0(%rbp), %rdi
callq 0x20f0
leaq -0x48(%rbp), %rdi
callq 0x3250
jmp 0x25c4
leaq -0x48(%rbp), %rdi
callq 0x26a0
jmp 0x25cf
movl $0x0, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20f0
movl -0x9c(%rbp), %eax
testl %eax, %eax
je 0x25f3
jmp 0x25ee
jmp 0x242b
jmp 0x242b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x20f0
leaq -0x68(%rbp), %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sanket143[P]2048-Terminal-Game/./src/board.h
// Function: gb::Board::add_tile()
void add_tile() {
      
        vector <int> available;

        for(int row = 0; row < 4; row++){
          for(int col = 0; col < 4; col++){
            if(tiles[row][col] == 0){
              available.push_back(row * 4 + col);
            }
          }
        }
        
        if(available.size() == 0) {
          printf("Game Over\n");
          exit(0);
        }
        int random_empty_tile = available[(int)(rand() % (int)available.size())];
        tiles[random_empty_tile / 4][random_empty_tile % 4] = 2;
          
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bf0
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x32f8
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x32e8
movq -0x48(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x32db
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3c10
jmp 0x32bf
jmp 0x32db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3c80
jmp 0x3390
jmp 0x32dd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3281
jmp 0x32ea
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3274
leaq -0x20(%rbp), %rdi
callq 0x3c40
cmpq $0x0, %rax
jne 0x331e
leaq 0x1d91(%rip), %rdi      # 0x509f
xorl %eax, %eax
callq 0x2030
jmp 0x3317
xorl %edi, %edi
callq 0x21f0
callq 0x2050
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3c40
movq %rax, %rcx
movl -0x54(%rbp), %eax
cltd
idivl %ecx
movslq %edx, %rsi
leaq -0x20(%rbp), %rdi
callq 0x3c60
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x40(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x50(%rbp), %rax
movslq %edx, %rcx
movl $0x2, (%rax,%rcx,4)
leaq -0x20(%rbp), %rdi
callq 0x3c80
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2290
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: usage()
void usage() {
    cout << "Usage : nrf24lx1Flash -f [hexfile] -p port -b baudrate -r reset -b BL_enabled -c command\n";
    cout << "-f [hexfile], path to hex file\n";
    cout << "-p port, port device\n\t-default /dev/ttyUSB0 \n";
    cout << "-b baudrate, UART speed\n\t-default 38400 \n";
    cout << "-r reset, reset pin DTR, RTS or CTS\n\t-default DTR\n";
    cout << "-bl BL_enabled, DISABLED or DTR or RTS\n\t-default DISABLED\n";
    cout << "-c command, CHECK, FLASH\n\t-default CHECK\n";
    cout << "\nVersion " << version << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa53d(%rip), %rdi      # 0xdfd8
leaq 0x65bf(%rip), %rsi      # 0xa061
callq 0x32a0
movq 0xa52a(%rip), %rdi      # 0xdfd8
leaq 0x6606(%rip), %rsi      # 0xa0bb
callq 0x32a0
movq 0xa517(%rip), %rdi      # 0xdfd8
leaq 0x6613(%rip), %rsi      # 0xa0db
callq 0x32a0
movq 0xa504(%rip), %rdi      # 0xdfd8
leaq 0x662e(%rip), %rsi      # 0xa109
callq 0x32a0
movq 0xa4f1(%rip), %rdi      # 0xdfd8
leaq 0x6645(%rip), %rsi      # 0xa133
callq 0x32a0
movq 0xa4de(%rip), %rdi      # 0xdfd8
leaq 0x6665(%rip), %rsi      # 0xa166
callq 0x32a0
movq 0xa4cb(%rip), %rdi      # 0xdfd8
leaq 0x668d(%rip), %rsi      # 0xa1a1
callq 0x32a0
movq 0xa4b8(%rip), %rdi      # 0xdfd8
leaq 0x66a4(%rip), %rsi      # 0xa1cb
callq 0x32a0
movq %rax, %rdi
leaq 0xa7b2(%rip), %rsi      # 0xe2e8
callq 0x3270
movq %rax, %rdi
leaq 0x6f51(%rip), %rsi      # 0xaa96
callq 0x32a0
popq %rbp
retq
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: set_blocking(int, int)
void
set_blocking (int fd, int should_block)
{
        struct termios tty;
        memset (&tty, 0, sizeof tty);
        if (tcgetattr (fd, &tty) != 0)
        {
                cout << "error from tggetattr: " << errno;
                return;
        }

        tty.c_cc[VMIN]  = should_block ? 1 : 0;
        tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

        if (tcsetattr (fd, TCSANOW, &tty) != 0)
                cout << "error setting term attributes:"<<errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x44(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x31a0
movl -0x4(%rbp), %edi
leaq -0x44(%rbp), %rsi
callq 0x3350
cmpl $0x0, %eax
je 0x47f8
movq 0x9802(%rip), %rdi      # 0xdfd8
leaq 0x5c3a(%rip), %rsi      # 0xa417
callq 0x32a0
movq %rax, -0x50(%rbp)
callq 0x3060
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x34b0
jmp 0x4849
movl -0x8(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x2d(%rbp)
movb $0x5, -0x2e(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
leaq -0x44(%rbp), %rdx
callq 0x3380
cmpl $0x0, %eax
je 0x4849
movq 0x97af(%rip), %rdi      # 0xdfd8
leaq 0x5bfe(%rip), %rsi      # 0xa42e
callq 0x32a0
movq %rax, -0x58(%rbp)
callq 0x3060
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x34b0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: RtsSet(int, bool)
void RtsSet(int fd, bool value) {
    int sercmd = TIOCM_RTS;
    if(value) {
        ioctl(fd, TIOCMBIS, &sercmd); // Set the RTS pin.
    } else {
        ioctl(fd, TIOCMBIC, &sercmd); // Reset the RTS pin.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl $0x4, -0xc(%rbp)
testb $0x1, -0x5(%rbp)
je 0x4bd5
movl -0x4(%rbp), %edi
movl $0x5416, %esi           # imm = 0x5416
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
jmp 0x4be8
movl -0x4(%rbp), %edi
movl $0x5417, %esi           # imm = 0x5417
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: DtrSet(int, bool)
void DtrSet(int fd, bool value) {
    int sercmd = TIOCM_DTR;
    if(value) {
        ioctl(fd, TIOCMBIS, &sercmd); // Set the DTR pin.
    } else {
        ioctl(fd, TIOCMBIC, &sercmd); // Reset the DTR pin.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl $0x2, -0xc(%rbp)
testb $0x1, -0x5(%rbp)
je 0x4c25
movl -0x4(%rbp), %edi
movl $0x5416, %esi           # imm = 0x5416
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
jmp 0x4c38
movl -0x4(%rbp), %edi
movl $0x5417, %esi           # imm = 0x5417
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: CtsSet(int, bool)
void CtsSet(int fd, bool value) {
    int sercmd = TIOCM_CTS;
    if(value) {
        ioctl(fd, TIOCMBIS, &sercmd); // Set the CTS pin.
    } else {
        ioctl(fd, TIOCMBIC, &sercmd); // Reset the CTS pin.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl $0x20, -0xc(%rbp)
testb $0x1, -0x5(%rbp)
je 0x4c75
movl -0x4(%rbp), %edi
movl $0x5416, %esi           # imm = 0x5416
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
jmp 0x4c88
movl -0x4(%rbp), %edi
movl $0x5417, %esi           # imm = 0x5417
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: WriteSerialByte(unsigned char)
BLCommandReturnType WriteSerialByte(unsigned char buffer)
{
    try
    {
        write(progSerPort,&buffer,1);
        fsync(progSerPort);
	sleep_ms(1);
        return BLCommandReturnType_OK;
    }
    catch(...)
    {
        return BLCommandReturnType_SerialPortFailure;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movl 0x95e4(%rip), %edi      # 0xe3d8
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x3110
jmp 0x4e04
movl 0x95ce(%rip), %edi      # 0xe3d8
callq 0x3250
jmp 0x4e11
movl $0x1, %edi
callq 0x9810
jmp 0x4e1d
movl $0x0, -0x4(%rbp)
jmp 0x4e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3150
movl $0x3, -0x4(%rbp)
callq 0x3480
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ReadSerialDataByte(unsigned char*)
BLCommandReturnType ReadSerialDataByte(unsigned char *buffer)
{
  fd_set set;
  struct timeval timeout;
  int rv;

  FD_ZERO(&set); /* clear the set */
  FD_SET(progSerPort, &set); /* add our file descriptor to the set */

  timeout.tv_sec = 0;
  timeout.tv_usec = 2000000;

  rv = select(progSerPort + 1, &set, NULL, NULL, &timeout);
  if(rv == -1)
    return BLCommandReturnType_SerialPortFailure; /* an error accured */
  else if(rv == 0)
    return BLCommandReturnType_Timeout; /* a timeout occured */
  else
    read( progSerPort, (void *)buffer,1 ); /* there was data to read */

    return BLCommandReturnType_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
cmpq $0x10, %rax
jae 0x4ea9
movq -0xb0(%rbp), %rax
movl -0xa8(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x4e77
jmp 0x4eab
movl 0x9527(%rip), %eax      # 0xe3d8
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl 0x950a(%rip), %eax      # 0xe3d8
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movq $0x0, -0xa0(%rbp)
movq $0x1e8480, -0x98(%rbp) # imm = 0x1E8480
movl 0x94d4(%rip), %edi      # 0xe3d8
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa0(%rbp), %r8
movq %rcx, %rdx
callq 0x3280
movl %eax, -0xa4(%rbp)
cmpl $-0x1, -0xa4(%rbp)
jne 0x4f39
movl $0x3, -0x4(%rbp)
jmp 0x4f68
cmpl $0x0, -0xa4(%rbp)
jne 0x4f4b
movl $0x2, -0x4(%rbp)
jmp 0x4f68
movl 0x9487(%rip), %edi      # 0xe3d8
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3400
jmp 0x4f61
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ReadSerialCommandByte(BLCommand)
BLCommandReturnType ReadSerialCommandByte(BLCommand command)
{
    unsigned char buffer = 0;
    BLCommandReturnType blCommandReturnVal;

    blCommandReturnVal = ReadSerialDataByte(&buffer);

    if (blCommandReturnVal == BLCommandReturnType_OK)
    {
        if ((command == BLCommand_Any) || (buffer == (char)command))
        {
            return BLCommandReturnType_OK;
        }
        else
        {
            return BLCommandReturnType_BadCharacter;
        }
    }
    else
    {
        return blCommandReturnVal;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x4e50
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x4fc7
cmpl $0x2a, -0x8(%rbp)
je 0x4fb5
movzbl -0x9(%rbp), %eax
movl -0x8(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4fbe
movl $0x0, -0x4(%rbp)
jmp 0x4fcd
movl $0x1, -0x4(%rbp)
jmp 0x4fcd
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandStartBootloader()
BLCommandReturnType ExecuteCommandStartBootloader()
{
    if (!OpenSerialPort(baudrate))
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    //reset the chip
    ResetDevice();

    //send the start byte
    if (WriteSerialByte((unsigned char)BLCommand_Start) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    //wait for the return character and return it
    return ReadSerialCommandByte(BLCommand_Start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x92d2(%rip), %edi      # 0xe2c0
callq 0x4850
testb $0x1, %al
jne 0x5000
movl $0x3, -0x4(%rbp)
jmp 0x502a
callq 0x4c90
movl $0x73, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x501d
movl $0x3, -0x4(%rbp)
jmp 0x502a
movl $0x73, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandGetDevID(unsigned short*)
BLCommandReturnType ExecuteCommandGetDevID(uint16_t *buffer)
{
    unsigned char tempByte = 0;

    if (WriteSerialByte((unsigned char )BLCommand_GetDevID) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (ReadSerialDataByte(&tempByte) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_Timeout;
    }

    *buffer = tempByte;

    if (ReadSerialDataByte(&tempByte) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_Timeout;
    }

    (*buffer) += ((uint16_t)tempByte) << 8;

    return ReadSerialCommandByte(BLCommand_GetDevID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x69, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5068
movl $0x3, -0x4(%rbp)
jmp 0x50c7
leaq -0x11(%rbp), %rdi
callq 0x4e50
cmpl $0x0, %eax
je 0x507f
movl $0x2, -0x4(%rbp)
jmp 0x50c7
movzbl -0x11(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
leaq -0x11(%rbp), %rdi
callq 0x4e50
cmpl $0x0, %eax
je 0x50a4
movl $0x2, -0x4(%rbp)
jmp 0x50c7
movzbl -0x11(%rbp), %eax
movzwl %ax, %edx
shll $0x8, %edx
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
movl $0x69, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandGetBLVersion(unsigned char*)
BLCommandReturnType ExecuteCommandGetBLVersion(unsigned char *buffer)
{
    if (WriteSerialByte((unsigned char)BLCommand_GetBLVersion) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (ReadSerialDataByte(buffer) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_Timeout;
    }

    return ReadSerialCommandByte(BLCommand_GetBLVersion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x76, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x50f4
movl $0x3, -0x4(%rbp)
jmp 0x5118
movq -0x10(%rbp), %rdi
callq 0x4e50
cmpl $0x0, %eax
je 0x510b
movl $0x2, -0x4(%rbp)
jmp 0x5118
movl $0x76, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandExitBootloader()
BLCommandReturnType ExecuteCommandExitBootloader()
{
    BLCommandReturnType retVal = BLCommandReturnType_Timeout;

    if (WriteSerialByte((unsigned char)BLCommand_Exit) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    retVal = ReadSerialCommandByte(BLCommand_Exit);

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, -0x8(%rbp)
movl $0x78, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5157
movl $0x3, -0x4(%rbp)
jmp 0x516a
movl $0x78, %edi
callq 0x4f80
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ConvertBLDevIDToString[abi:cxx11](unsigned short)
string ConvertBLDevIDToString(uint16_t blDevId)
{
    string retVal;

    if(blDevId >= sizeof(&blDevIdToString))
    {
        retVal = "[Invalid Device ID]";
    }
    else
    {
        retVal = blDevIdToString[blDevId];
    }

    retVal += " (ID: " + ToString(blDevId) + ")\n";

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
callq 0x33d0
movzwl -0xa(%rbp), %eax
cmpq $0x8, %rax
jb 0x51e2
movq -0x90(%rbp), %rdi
leaq 0x52f2(%rip), %rsi      # 0xa4ba
callq 0x33c0
jmp 0x51cf
jmp 0x5203
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x52d8
movq -0x90(%rbp), %rdi
movzwl -0xa(%rbp), %eax
shll $0x5, %eax
leaq 0x9119(%rip), %rsi      # 0xe310
addq %rax, %rsi
callq 0x3050
jmp 0x5201
jmp 0x5203
leaq -0x80(%rbp), %rdi
leaq -0xa(%rbp), %rsi
callq 0x75e0
jmp 0x5212
leaq 0x52b5(%rip), %rsi      # 0xa4ce
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x7590
jmp 0x5228
leaq 0x52a6(%rip), %rdx      # 0xa4d5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7530
jmp 0x523e
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3390
jmp 0x5250
leaq -0x40(%rbp), %rdi
callq 0x3568
leaq -0x60(%rbp), %rdi
callq 0x3568
leaq -0x80(%rbp), %rdi
callq 0x3568
movb $0x1, -0xb(%rbp)
testb $0x1, -0xb(%rbp)
jne 0x52c8
jmp 0x52bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x52b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x52a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3568
leaq -0x60(%rbp), %rdi
callq 0x3568
leaq -0x80(%rbp), %rdi
callq 0x3568
jmp 0x52d8
movq -0x90(%rbp), %rdi
callq 0x3568
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3568
movq -0x18(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandErasePage(unsigned char)
BLCommandReturnType ExecuteCommandErasePage(uint8_t pageNum)
{
    if (WriteSerialByte((uint8_t)BLCommand_ErasePage) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (WriteSerialByte(pageNum) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    return ReadSerialCommandByte(BLCommand_ErasePage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x65, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5536
movl $0x3, -0x4(%rbp)
jmp 0x555a
movzbl -0x5(%rbp), %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x554d
movl $0x3, -0x4(%rbp)
jmp 0x555a
movl $0x65, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandSetRWAddress(unsigned short)
BLCommandReturnType ExecuteCommandSetRWAddress(uint16_t address)
{
    if (WriteSerialByte((uint8_t)BLCommand_SetRWAddress) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (WriteSerialByte((uint8_t)address & 0xFF) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (WriteSerialByte((uint8_t)(address >> 8)) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    return ReadSerialCommandByte(BLCommand_SetRWAddress);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movl $0x61, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5597
movl $0x3, -0x4(%rbp)
jmp 0x55e3
movw -0x6(%rbp), %ax
movzbl %al, %eax
andl $0xff, %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x55b9
movl $0x3, -0x4(%rbp)
jmp 0x55e3
movzwl -0x6(%rbp), %eax
sarl $0x8, %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x55d6
movl $0x3, -0x4(%rbp)
jmp 0x55e3
movl $0x61, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandWrite(unsigned char*, unsigned short, unsigned short)
BLCommandReturnType ExecuteCommandWrite(uint8_t buffer[], uint16_t startIndex, uint16_t len)
{
    uint numWritten = 0;

    while(numWritten < len)
    {
        uint numToWrite;

        //The write operation only supports writing up to 256 bytes per write
        if ((len - numWritten) > 256)
        {
            numToWrite = 256;
        }
        else
        {
            numToWrite = len - numWritten;
        }

        //Send write command
        if (WriteSerialByte((uint8_t)BLCommand_Write) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_SerialPortFailure;
        }

        //Send number of bytes to be written (0 here indicates we want to write 256 bytes, so casting numToWrite to a byte does the trick of getting rid of the MSb)
        if (WriteSerialByte((uint8_t)numToWrite) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_SerialPortFailure;
        }

        //Send the bytes to be written one by one
        for(unsigned int x = 0; x < numToWrite; x++)
        {
            if (WriteSerialByte(buffer[startIndex + numWritten]) != BLCommandReturnType_OK)
            {
                return BLCommandReturnType_SerialPortFailure;
            }

            numWritten++;
        }

        if (ReadSerialCommandByte(BLCommand_Write) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_Timeout;
        }
    }

    return BLCommandReturnType_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jae 0x56d9
movzwl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jbe 0x5637
movl $0x100, -0x1c(%rbp)     # imm = 0x100
jmp 0x5641
movzwl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x77, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x565c
movl $0x3, -0x4(%rbp)
jmp 0x56e0
movl -0x1c(%rbp), %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5675
movl $0x3, -0x4(%rbp)
jmp 0x56e0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x56bc
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x56a8
movl $0x3, -0x4(%rbp)
jmp 0x56e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x567c
movl $0x77, %edi
callq 0x4f80
cmpl $0x0, %eax
je 0x56d4
movl $0x2, -0x4(%rbp)
jmp 0x56e0
jmp 0x5611
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandSetUsrMainAddress(unsigned short)
BLCommandReturnType ExecuteCommandSetUsrMainAddress(uint16_t address)
{
    if (WriteSerialByte((uint8_t)BLCommand_SetUsrMainAddress) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (WriteSerialByte((uint8_t)address & 0xFF) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    if (WriteSerialByte((uint8_t)address >> 8) != BLCommandReturnType_OK)
    {
        return BLCommandReturnType_SerialPortFailure;
    }

    return ReadSerialCommandByte(BLCommand_SetUsrMainAddress);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movl $0x6d, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5717
movl $0x3, -0x4(%rbp)
jmp 0x5766
movw -0x6(%rbp), %ax
movzbl %al, %eax
andl $0xff, %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5739
movl $0x3, -0x4(%rbp)
jmp 0x5766
movw -0x6(%rbp), %ax
movzbl %al, %eax
sarl $0x8, %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x5759
movl $0x3, -0x4(%rbp)
jmp 0x5766
movl $0x6d, %edi
callq 0x4f80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: ExecuteCommandRead(unsigned char*, unsigned short, unsigned short)
BLCommandReturnType ExecuteCommandRead(uint8_t buffer[], uint16_t startIndex, uint16_t len)
{
    unsigned int numRead = 0;

    while(numRead < len)
    {
        unsigned int numToRead;

        //The read operation only supports reading up to 256 bytes per read
        if ((len - numRead) > 256)
        {
            numToRead = 256;
        }
        else
        {
            numToRead = len - numRead;
        }

        //Send read command
        if (WriteSerialByte((uint8_t)BLCommand_Read) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_SerialPortFailure;
        }

        //Send number of bytes to be read (0 here indicates we want to read 256 bytes, so casting numToRead to a byte does the trick of getting rid of the MSb)
        if (WriteSerialByte((uint8_t)numToRead) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_SerialPortFailure;
        }

        //Read in the bytes from the micro one by one
        for(unsigned int x = 0; x < numToRead; x++)
        {
            if (ReadSerialDataByte(&buffer[startIndex + numRead]) != BLCommandReturnType_OK)
            {
                return BLCommandReturnType_SerialPortFailure;
            }

            numRead++;
        }

        if (ReadSerialCommandByte(BLCommand_Read) != BLCommandReturnType_OK)
        {
            return BLCommandReturnType_Timeout;
        }
    }

    return BLCommandReturnType_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jae 0x5858
movzwl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jbe 0x57b7
movl $0x100, -0x1c(%rbp)     # imm = 0x100
jmp 0x57c1
movzwl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x72, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x57dc
movl $0x3, -0x4(%rbp)
jmp 0x585f
movl -0x1c(%rbp), %eax
movzbl %al, %edi
callq 0x4de0
cmpl $0x0, %eax
je 0x57f5
movl $0x3, -0x4(%rbp)
jmp 0x585f
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x583b
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, %eax
addq %rax, %rdi
callq 0x4e50
cmpl $0x0, %eax
je 0x5827
movl $0x3, -0x4(%rbp)
jmp 0x585f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57fc
movl $0x72, %edi
callq 0x4f80
cmpl $0x0, %eax
je 0x5853
movl $0x2, -0x4(%rbp)
jmp 0x585f
jmp 0x5791
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gulamf[P]NRF24LE1Flash/main.cpp
// Function: main
int main(int argc, char **argv)
{
    if(argc==1) usage();
    if(!processCommandLine(argc, argv)) exit(0);
    if(command==C_CHECK) {
        if(!CheckUC()) return -1;
    } else
    {
        if(!ProgramUC()) return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x7311
callq 0x3a90
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3b50
testb $0x1, %al
jne 0x7328
xorl %edi, %edi
callq 0x3360
cmpl $0x0, 0x70a5(%rip)      # 0xe3d4
jne 0x7345
callq 0x52f0
testb $0x1, %al
jne 0x7343
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7360
jmp 0x7359
callq 0x5870
testb $0x1, %al
jne 0x7357
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7360
jmp 0x7359
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: gulamf[P]NRF24LE1Flash/./include/misc.h
// Function: int ParseHex<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T ParseHex(const std::string& str) {
    T value = 0;
    for(unsigned int i=0;i<str.length();i++) {
        value = value << 4;
        if(str[i]>='0' && str[i]<='9') {
            int v = str[i]-'0';
            value += v;
        }
        else if(str[i]>='A' && str[i]<='F') {
            int v = str[i]-'A' + 10;
            value += v;
        }
    }
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3420
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x8a12
movl -0xc(%rbp), %eax
shll $0x4, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x89b1
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x89b1
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8a02
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x8a00
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x46, %eax
jg 0x8a00
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8a02
jmp 0x8a04
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x893a
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: getrandom(int)
const int getrandom (const int x)
{
	if (x <= 0)
		return 0;

	// r will be between 0 and 1 (but below 1 as we are dividing by RAND_MAX+1)
	double r = static_cast<double> (std::rand () % RAND_MAX) / (static_cast<double> (RAND_MAX) + 1.0);
	return floor (r * x);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x902a
movl $0x0, -0x4(%rbp)
jmp 0x9066
callq 0x8150
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
movsd 0x6cfc5(%rip), %xmm1    # 0x76008
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x8950
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: melop[P]admixem/./parser/parser.cpp
// Function: roll(int, int)
const int roll (const int howmany, const int die)
{
	int count;
	int total = 0;

	for (count = 0; count < howmany; ++count)
		total += getrandom (die) + 1;

	return total;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x90b0
movl -0x8(%rbp), %edi
callq 0x9010
addl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x908c
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: percent(int)
const bool percent (const int prob)
  {
  if (prob <= 0)
    return false;
  if (prob >= 100)
    return true;

  return getrandom (100) > (100 - prob);

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x90d7
movb $0x0, -0x1(%rbp)
jmp 0x90ff
cmpl $0x64, -0x8(%rbp)
jl 0x90e3
movb $0x1, -0x1(%rbp)
jmp 0x90ff
movl $0x64, %edi
callq 0x9010
movl $0x64, %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::Expression(bool)
const double Parser::Expression (const bool get)  // AND and OR
  {
  double left = Comparison (get);
  while (true)
    {
    switch (type_)
      {
      case AND: 
            {
            double d = Comparison (true);   // don't want short-circuit evaluation
            left = (left != 0.0) && (d != 0.0); 
            }
          break;
      case OR:  
            {
            double d = Comparison (true);   // don't want short-circuit evaluation
            left = (left != 0.0) || (d != 0.0); 
            }
          break;
      default:    return left;
      } // end of switch on type
    }   // end of loop
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xbf50
movsd %xmm0, -0x18(%rbp)
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x43, %eax
je 0xbc7c
jmp 0xbc6f
movl -0x34(%rbp), %eax
subl $0x44, %eax
je 0xbcd0
jmp 0xbd22
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xbf50
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x35(%rbp)
jne 0xbca6
jp 0xbca6
jmp 0xbcbd
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbd2d
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xbf50
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x36(%rbp)
jne 0xbd0f
jp 0xbd0f
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x36(%rbp)
movb -0x36(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbd2d
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
jmp 0xbc5e
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::CommaList(bool)
const double Parser::CommaList (const bool get)  // expr1, expr2
  {
  double left = Expression (get);
  while (true)
    {
    switch (type_)
      {
      case COMMA:  left = Expression (true); break; // discard previous value
      default:    return left;
      } // end of switch on type
    }   // end of loop
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xbc30
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
subl $0x2c, %eax
jne 0xbd91
jmp 0xbd7c
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xbc30
movsd %xmm0, -0x18(%rbp)
jmp 0xbd9c
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
jmp 0xbd6e
nop
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::Term(bool)
const double Parser::Term (const bool get)    // multiply and divide
  {
  double left = Primary (get);
  while (true)
    {
    switch (type_)
      {
      case MULTIPLY:  
        left *= Primary (true); break;
      case DIVIDE: 
          {
          double d = Primary (true);
          if (d == 0.0)
            throw std::runtime_error ("Divide by zero");
          left /= d; 
          break;
          }
      default:    return left;
      } // end of switch on type
    }   // end of loop
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xb2a0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x2a, %eax
je 0xbdec
jmp 0xbddf
movl -0x3c(%rbp), %eax
subl $0x2f, %eax
je 0xbe09
jmp 0xbe91
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xb2a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbe9c
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xb2a0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbe7c
jp 0xbe7c
movl $0x10, %edi
callq 0x8230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x6a56b(%rip), %rsi     # 0x763b2
callq 0x81b0
jmp 0xbe4e
movq -0x48(%rbp), %rdi
movq 0x9e197(%rip), %rsi     # 0xa9ff0
movq 0x9e120(%rip), %rdx     # 0xa9f80
callq 0x8820
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8370
jmp 0xbea1
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbe9c
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
jmp 0xbdce
movq -0x28(%rbp), %rdi
callq 0x8860
nopw (%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::AddSubtract(bool)
const double Parser::AddSubtract (const bool get)  // add and subtract
  {
  double left = Term (get);
  while (true)
    {
    switch (type_)
      {
      case PLUS:  left += Term (true); break;
      case MINUS: left -= Term (true); break;
      default:    return left;
      } // end of switch on type
    }   // end of loop
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xbda0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2b, %eax
je 0xbef9
jmp 0xbeef
movl -0x24(%rbp), %eax
subl $0x2d, %eax
je 0xbf13
jmp 0xbf34
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xbda0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbf3f
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xbda0
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xbf3f
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
jmp 0xbede
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::Evaluate()
const double Parser::Evaluate ()  // get result
  {
  pWord_    = program_.c_str ();
  type_     = NONE;
  double v = CommaList (true);
  if (type_ != END)
    throw std::runtime_error ("Unexpected text at end of expression: " + std::string (pWordStart_));
  return v;  
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x81d0
movq -0x70(%rbp), %rdi
movq %rax, 0x20(%rdi)
movl $0x0, 0x30(%rdi)
movl $0x1, %esi
callq 0xbd40
movq -0x70(%rbp), %rax
movsd %xmm0, -0x10(%rbp)
cmpl $0x3, 0x30(%rax)
je 0xc29d
movb $0x1, -0x65(%rbp)
movl $0x10, %edi
callq 0x8230
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8870
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xcb30
jmp 0xc1fc
leaq 0x6a1d1(%rip), %rsi     # 0x763d4
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xc500
jmp 0xc212
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x87a0
jmp 0xc224
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
movq 0x9ddba(%rip), %rsi     # 0xa9ff0
movq 0x9dd43(%rip), %rdx     # 0xa9f80
callq 0x8820
jmp 0xc2b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc27e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc275
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x82e0
leaq -0x50(%rbp), %rdi
callq 0x82e0
leaq -0x51(%rbp), %rdi
callq 0x8540
testb $0x1, -0x65(%rbp)
jne 0xc28f
jmp 0xc29b
movq -0x88(%rbp), %rdi
callq 0x8370
jmp 0xc2ab
movsd -0x10(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/./parser/parser.cpp
// Function: Parser::Evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const double Parser::Evaluate (const std::string & program)  // get result
  {
  program_  = program;
  this->IsOne = (program=="1");
  this->IsZero =  (program=="0");
  return Evaluate ();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8070
movq -0x10(%rbp), %rdi
leaq 0x6d351(%rip), %rsi     # 0x7963d
callq 0xcbe0
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x60(%rax)
movq -0x10(%rbp), %rdi
leaq 0x6b9f3(%rip), %rsi     # 0x77cfb
callq 0xcbe0
movq -0x18(%rbp), %rdi
andb $0x1, %al
movb %al, 0x61(%rdi)
callq 0xc170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: melop[P]admixem/./parser/parser.h
// Function: Parser::CheckToken(Parser::TokenType)
inline void CheckToken (const TokenType wanted)
    {
    if (type_ != wanted)
      {
      std::ostringstream s;
      s << "'" << static_cast <char> (wanted) << "' expected.";
      throw std::runtime_error (s.str ());    
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc7e4
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x8680
movq -0x1d0(%rbp), %rdi
leaq 0x69cca(%rip), %rsi     # 0x7639d
callq 0x84a0
movq %rax, -0x1c8(%rbp)
jmp 0xc6e1
movq -0x1c8(%rbp), %rdi
movsbl -0xc(%rbp), %esi
callq 0x85d0
movq %rax, -0x1d8(%rbp)
jmp 0xc6fa
movq -0x1d8(%rbp), %rdi
leaq 0x69d59(%rip), %rsi     # 0x76461
callq 0x84a0
jmp 0xc70f
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x8230
movq %rax, -0x1e0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x84e0
jmp 0xc73c
movq -0x1e0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x87a0
jmp 0xc751
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x9d88a(%rip), %rsi     # 0xa9ff0
movq 0x9d813(%rip), %rdx     # 0xa9f80
callq 0x8820
jmp 0xc7f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xc7d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xc7bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x82e0
testb $0x1, -0x1b9(%rbp)
jne 0xc7c8
jmp 0xc7d4
movq -0x1e0(%rbp), %rdi
callq 0x8370
jmp 0xc7d6
leaq -0x188(%rbp), %rdi
callq 0x8120
jmp 0xc7ed
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x8860
nopl (%rax)
// File: melop[P]admixem/./newran02/extreal.cpp
// Function: ExtReal::operator+(ExtReal const&) const
ExtReal ExtReal::operator+(const ExtReal& er) const
{
   if (c==Finite && er.c==Finite) return ExtReal(value+er.value);
   if (c==Missing || er.c==Missing) return ExtReal(Missing);
   if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite);
   if (c==PlusInfinity)
   {
      if (er.c==MinusInfinity) return ExtReal(Indefinite);
      return *this;
   }
   if (c==MinusInfinity)
   {
      if (er.c==PlusInfinity) return ExtReal(Indefinite);
      return *this;
   }
   return er;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x11bd6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x11bd6
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
leaq -0x10(%rbp), %rdi
callq 0x12180
jmp 0x11cc1
movq -0x38(%rbp), %rax
cmpl $0x4, 0x8(%rax)
je 0x11bea
movq -0x20(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x11c03
movl $0x4, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x121b0
jmp 0x11cc1
movq -0x38(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0x11c17
movq -0x20(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x11c30
movl $0x3, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x121b0
jmp 0x11cc1
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x11c6f
movq -0x20(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x11c5a
movl $0x3, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x121b0
jmp 0x11cc1
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11cc1
movq -0x38(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x11cae
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x11c99
movl $0x3, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x121b0
jmp 0x11cc1
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11cc1
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movl -0x8(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: melop[P]admixem/./newran02/extreal.cpp
// Function: ExtReal::operator-() const
ExtReal ExtReal::operator-() const
{
   switch (c)
   {
      case Finite:        return ExtReal(-value);
      case PlusInfinity:  return ExtReal(MinusInfinity);
      case MinusInfinity: return ExtReal(PlusInfinity);
      case Indefinite:    return ExtReal(Indefinite);
      case Missing:       return ExtReal(Missing);
   }
   return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x8(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x120bb
movq -0x30(%rbp), %rax
leaq 0x64468(%rip), %rcx     # 0x76498
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
leaq -0x10(%rbp), %rdi
callq 0x12180
jmp 0x120c7
movl $0x2, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x121b0
jmp 0x120c7
movl $0x1, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x121b0
jmp 0x120c7
movl $0x3, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x121b0
jmp 0x120c7
movl $0x4, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x121b0
jmp 0x120c7
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x12180
movsd -0x10(%rbp), %xmm0
movl -0x8(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)