LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: blakewford[P]kab/main.cpp
// Function: printTargets(bool)
void printTargets(bool cache)
{
    printf("Found (%zd)\n", gFound.size());

    int32_t count = 0;
    auto iter = gFound.begin();
    while(iter != gFound.end())
    {
        printf("[%d] %s\n", count, iter->name);
        if(cache)
        {
            FILE* json = fopen("cache.json", "a");
            fprintf(json, "{\"name\":\"%s\",\"parameters\":{\"ip\":\"%s\",\"model\":\"%s\"}}\n", iter->name, iter->ip, iter->model);
            fclose(json);
        }
        count++;
        iter++;
    }
}

// Assembly:
subq $0x48, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x47(%rsp)
leaq 0x9ad4(%rip), %rdi      # 0xc2f8
callq 0x3910
movq %rax, %rsi
leaq 0x57d1(%rip), %rdi      # 0x8004
movb $0x0, %al
callq 0x2030
movl $0x0, 0x40(%rsp)
leaq 0x9aaf(%rip), %rdi      # 0xc2f8
callq 0x3930
movq %rax, 0x38(%rsp)
leaq 0x9a9e(%rip), %rdi      # 0xc2f8
callq 0x39a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3960
testb $0x1, %al
jne 0x287c
jmp 0x2953
movl 0x40(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x39d0
movl 0x1c(%rsp), %esi
movq %rax, %rdx
addq $0x2a, %rdx
leaq 0x5771(%rip), %rdi      # 0x8011
movb $0x0, %al
callq 0x2030
testb $0x1, 0x47(%rsp)
je 0x2932
leaq 0x5761(%rip), %rdi      # 0x801a
leaq 0x5765(%rip), %rsi      # 0x8025
callq 0x2280
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x39d0
addq $0x2a, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x39d0
addq $0x182, %rax            # imm = 0x182
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x39d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
addq $0xa, %r8
leaq 0x5706(%rip), %rsi      # 0x8027
movb $0x0, %al
callq 0x22f0
movq 0x28(%rsp), %rdi
callq 0x2230
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x39e0
movq %rax, 0x20(%rsp)
jmp 0x2853
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: quit(int)
void quit(int sock)
{
    gKeepGoing = false;
    pthread_join(gRecvP1, nullptr);
    pthread_join(gRecvP1, nullptr);

    printTargets(true);

    close(sock);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movb $0x0, 0x98a4(%rip)      # 0xc210
movq 0x9975(%rip), %rdi      # 0xc2e8
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq 0x9965(%rip), %rdi      # 0xc2e8
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movl $0x1, %edi
callq 0x2810
movl 0x4(%rsp), %edi
callq 0x23f0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: timeoutThread(void*)
void* timeoutThread(void* arg)
{
    int sock = *(int*)arg;

    usleep(TIMEOUT);
    quit(sock);

    exit(-1);

    return nullptr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x989680, %edi         # imm = 0x989680
callq 0x22e0
movl 0xc(%rsp), %edi
callq 0x2960
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: recvBroadcast(void*)
void* recvBroadcast(void* arg)
{
    broadcastParams* params = (broadcastParams*)arg;

    struct sockaddr_in server = buildServerType(INADDR_BROADCAST, params->port);

    response target;
    socklen_t length;
    uint8_t buffer[RESPONSE_SIZE];

    while(gKeepGoing)
    {
        ssize_t recv = recvfrom(params->socket, buffer, RESPONSE_SIZE, 0, (sockaddr*)&server, &length);
        memcpy(&target, buffer, RESPONSE_SIZE);

        std::lock_guard<std::mutex> lock(gResponseMutex);

        bool found = false;
        auto iter = gFound.begin();
        while(iter != gFound.end())
        {
            if(!strcmp(iter->serial, target.serial))
            {
                found = true;
                break;
            }
            iter++;
        }
        if(!found)
        {
            gFound.push_back(target);
        }
    }

    return nullptr;
}

// Assembly:
subq $0x398, %rsp            # imm = 0x398
movq %rdi, 0x390(%rsp)
movq 0x390(%rsp), %rax
movq %rax, 0x388(%rsp)
movq 0x388(%rsp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movzwl 0x4(%rax), %esi
callq 0x2570
movq %rax, 0x378(%rsp)
movq %rdx, 0x380(%rsp)
testb $0x1, 0x97d4(%rip)      # 0xc210
je 0x2b5f
movq 0x388(%rsp), %rax
movl (%rax), %edi
leaq 0x40(%rsp), %rsi
movl $0x198, %edx            # imm = 0x198
xorl %ecx, %ecx
leaq 0x378(%rsp), %r8
leaq 0x1dc(%rsp), %r9
callq 0x21a0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x1e0(%rsp), %rdi
movl $0x198, %edx            # imm = 0x198
callq 0x21c0
leaq 0x30(%rsp), %rdi
leaq 0x982b(%rip), %rsi      # 0xc2c0
callq 0x3a20
movb $0x0, 0x2f(%rsp)
leaq 0x9852(%rip), %rdi      # 0xc2f8
callq 0x3930
movq %rax, 0x20(%rsp)
leaq 0x9841(%rip), %rdi      # 0xc2f8
callq 0x39a0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3960
testb $0x1, %al
jne 0x2ad6
jmp 0x2b17
leaq 0x20(%rsp), %rdi
callq 0x39d0
movq %rax, %rdi
addq $0x4a, %rdi
leaq 0x1e0(%rsp), %rsi
addq $0x4a, %rsi
callq 0x22d0
cmpl $0x0, %eax
jne 0x2b04
movb $0x1, 0x2f(%rsp)
jmp 0x2b17
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x39e0
movq %rax, 0x10(%rsp)
jmp 0x2ab0
testb $0x1, 0x2f(%rsp)
jne 0x2b50
leaq 0x97d3(%rip), %rdi      # 0xc2f8
leaq 0x1e0(%rsp), %rsi
callq 0x3a50
jmp 0x2b34
jmp 0x2b50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3ad0
jmp 0x2b69
leaq 0x30(%rsp), %rdi
callq 0x3ad0
jmp 0x2a35
xorl %eax, %eax
addq $0x398, %rsp            # imm = 0x398
retq
movq 0x8(%rsp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: discoverWemo()
void discoverWemo()
{
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if(sock < 0) return;

    int32_t broadcast = 1;
    int ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
    if(ret != 0) return;

    struct sockaddr_in server = buildServerType(inet_addr(SSDP), DISCOVER_WEMO);
    server.sin_port = htons(DISCOVER_WEMO);

    broadcastParams params1;
    params1.socket = sock;
    params1.port = DISCOVER_WEMO;

    pthread_t watchDog;
    pthread_create(&gRecvP1,  nullptr, recvBroadcast, &params1);
    pthread_create(&watchDog, nullptr, timeoutThread, &sock);

    const char* packet =
"M-SEARCH * HTTP/1.1\r\n"\
"HOST: 239.255.255.250:1900\r\n"\
"MAN: \"ssdp:discover\"\r\n"\
"MX: 10\r\n"\
//"ST: ssdp:all\r\n";
"ST: urn:Belkin:device:controllee:1\r\n\r\n";

    ssize_t sent = sendto(sock, packet, strlen(packet), 0, (sockaddr*)&server, sizeof(server));
    usleep(1000*1000*1);

    quit(sock);
}

// Assembly:
subq $0x58, %rsp
movl $0x2, %esi
movl $0x11, %edx
movl %esi, %edi
callq 0x2080
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jge 0x2d95
jmp 0x2e9f
movl $0x1, 0x50(%rsp)
movl 0x54(%rsp), %edi
movl $0x1, %esi
movl $0x6, %edx
leaq 0x50(%rsp), %rcx
movl $0x4, %r8d
callq 0x23c0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
je 0x2dcb
jmp 0x2e9f
leaq 0x528a(%rip), %rdi      # 0x805c
callq 0x2250
movl %eax, %edi
movl $0x76c, %esi            # imm = 0x76C
callq 0x2570
movq %rax, 0x3c(%rsp)
movq %rdx, 0x44(%rsp)
movl $0x76c, %edi            # imm = 0x76C
callq 0x2040
movw %ax, 0x3e(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x34(%rsp)
movw $0x76c, 0x38(%rsp)      # imm = 0x76C
leaq 0x94d6(%rip), %rdi      # 0xc2e8
xorl %eax, %eax
movl %eax, %esi
leaq -0x42d(%rip), %rdx      # 0x29f0
leaq 0x34(%rsp), %rcx
callq 0x23d0
leaq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x487(%rip), %rdx      # 0x29b0
leaq 0x54(%rsp), %rcx
callq 0x23d0
leaq 0x5224(%rip), %rax      # 0x806c
movq %rax, 0x20(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2100
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
leaq 0x3c(%rsp), %r8
movl $0x10, %r9d
callq 0x2050
movq %rax, 0x18(%rsp)
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x22e0
movl 0x54(%rsp), %edi
callq 0x2960
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: addCachedTarget(set_target&)
void addCachedTarget(set_target& t)
{
    response r;
    memset(&r, '\0', RESPONSE_SIZE);

    memcpy(r.name, t.get_name(), strlen(t.get_name()));
    memcpy(r.ip, t.get_ip(), strlen(t.get_ip()));
    memcpy(r.model, t.get_model(), strlen(t.get_model()));
    gFound.push_back(r);
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movl $0x198, %edx            # imm = 0x198
callq 0x2130
leaq 0x38(%rsp), %rax
addq $0x2a, %rax
movq %rax, 0x8(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3af0
movq %rax, 0x10(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3af0
movq %rax, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
leaq 0x38(%rsp), %rax
addq $0x182, %rax            # imm = 0x182
movq %rax, 0x18(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3b00
movq %rax, 0x20(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3b00
movq %rax, %rdi
callq 0x2100
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
leaq 0x38(%rsp), %rax
addq $0xa, %rax
movq %rax, 0x28(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3b10
movq %rax, 0x30(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x3b10
movq %rax, %rdi
callq 0x2100
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
leaq 0x90aa(%rip), %rdi      # 0xc2f8
leaq 0x38(%rsp), %rsi
callq 0x3a50
addq $0x1d8, %rsp            # imm = 0x1D8
retq
// File: blakewford[P]kab/main.cpp
// Function: loop()
void loop()
{
    int fd = open("/sys/class/gpio/export", O_WRONLY);
    if(fd < 0) return;

    size_t written = write(fd, "24", 2);
    close(fd);

    fd = open("/sys/class/gpio/gpio24/direction", O_WRONLY);
    if(fd < 0) return;

    if(write(fd, "in", 2) < 0) return;
    close(fd);

    char valueString[3];
    fd = open("/sys/class/gpio/gpio24/value", O_RDONLY);
    while(read(fd, valueString, 3) > 0)
    {
        close(fd);

        int32_t value = atoi(valueString);
        printf("%d\n", value);
        toggle(0, value ? true: false);
        usleep(1000*1000);
        fd = open("/sys/class/gpio/gpio24/value", O_RDONLY);
        if(fd < 0) return;
    }
}

// Assembly:
subq $0x28, %rsp
leaq 0x505b(%rip), %rdi      # 0x82c6
movl $0x1, %esi
movb $0x0, %al
callq 0x2180
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x3287
jmp 0x3399
movl 0x24(%rsp), %edi
leaq 0x504b(%rip), %rsi      # 0x82dd
movl $0x2, %edx
callq 0x20c0
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %edi
callq 0x23f0
leaq 0x502f(%rip), %rdi      # 0x82e0
movl $0x1, %esi
movb $0x0, %al
callq 0x2180
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x32cd
jmp 0x3399
movl 0x24(%rsp), %edi
leaq 0x5029(%rip), %rsi      # 0x8301
movl $0x2, %edx
callq 0x20c0
cmpq $0x0, %rax
jge 0x32ed
jmp 0x3399
movl 0x24(%rsp), %edi
callq 0x23f0
leaq 0x5007(%rip), %rdi      # 0x8304
xorl %esi, %esi
movb $0x0, %al
callq 0x2180
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %edi
leaq 0x15(%rsp), %rsi
movl $0x3, %edx
callq 0x2300
cmpq $0x0, %rax
jle 0x3399
movl 0x24(%rsp), %edi
callq 0x23f0
leaq 0x15(%rsp), %rdi
callq 0x2350
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
leaq 0x4f7d(%rip), %rdi      # 0x82c2
xorl %eax, %eax
movl %eax, 0xc(%rsp)
callq 0x2030
movl 0xc(%rsp), %eax
movl 0x10(%rsp), %ecx
negl %ecx
sbbl %eax, %eax
xorl %ecx, %ecx
movzbl %al, %esi
andl $0x1, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x22e0
leaq 0x4f86(%rip), %rdi      # 0x8304
xorl %esi, %esi
movb $0x0, %al
callq 0x2180
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x3394
jmp 0x3399
jmp 0x330a
addq $0x28, %rsp
retq
nop
// File: blakewford[P]kab/parser.cpp
// Function: target::populate(container_object*)
void target::populate(container_object* obj)
{
    for(int i = 0; i < obj->child_count(); i++)
    {
        object* child = obj->at(i);
        switch(child->get_type())
        {
            case LONG:
                break;
            case STRING:
                assert(!strcmp("name", child->get_name()));
                memset(m_name, '\0', MAX_BUFFER_SIZE);
                memcpy(m_name, child->get_string_value(), strlen(child->get_string_value()));
                break;
            case CONTAINER:
                assert(!strcmp("parameters", child->get_name()));
                container_object* container = (container_object*)child;
                populate_specific(container);
                break;
        }
        delete child;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
callq 0x5000
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x47aa
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x5020
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x5050
movl %eax, %ecx
movl %ecx, 0x20(%rsp)
testl %eax, %eax
je 0x4676
jmp 0x4659
movl 0x20(%rsp), %eax
subl $0x1, %eax
je 0x467b
jmp 0x4664
movl 0x20(%rsp), %eax
subl $0x2, %eax
je 0x471d
jmp 0x477e
jmp 0x477e
movq 0x38(%rsp), %rdi
callq 0x5060
movq %rax, %rsi
leaq 0x3d85(%rip), %rdi      # 0x8414
callq 0x22d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x46a2
jmp 0x46a4
jmp 0x46c3
leaq 0x3d6e(%rip), %rdi      # 0x8419
leaq 0x3d8a(%rip), %rsi      # 0x843c
movl $0x57, %edx
leaq 0x3d89(%rip), %rcx      # 0x8447
callq 0x2160
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2130
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x477e
movq 0x38(%rsp), %rdi
callq 0x5060
movq %rax, %rsi
leaq 0x3d40(%rip), %rdi      # 0x8471
callq 0x22d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4744
jmp 0x4746
jmp 0x4765
leaq 0x3d2f(%rip), %rdi      # 0x847c
leaq 0x3ce8(%rip), %rsi      # 0x843c
movl $0x5c, %edx
leaq 0x3ce7(%rip), %rcx      # 0x8447
callq 0x2160
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4798
movq 0x8(%rsp), %rdi
callq 0x2210
jmp 0x479a
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x4610
addq $0x58, %rsp
retq
nop
// File: blakewford[P]kab/parser.cpp
// Function: set_target::populate_specific(container_object*)
void set_target::populate_specific(container_object* obj)
{
    container_object* container = (container_object*)obj;
    for(int i = 0; i < container->child_count(); i++)
    {
        object* param = container->at(i);
        const char* name = param->get_name();
        if(!strcmp(name, "ip"))
        {
            memcpy(m_ip, param->get_string_value(), strlen(param->get_string_value()));
        }
        else if(!strcmp(name, "model"))
        {
            memcpy(m_model, param->get_string_value(), strlen(param->get_string_value()));
        }
        else
        {
            assert(0);
        }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5000
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x4907
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x5020
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5060
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x3c7d(%rip), %rsi      # 0x84a5
callq 0x22d0
cmpl $0x0, %eax
jne 0x4877
movq 0x30(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rdi
callq 0x2100
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x48f5
movq 0x38(%rsp), %rdi
leaq 0x3c25(%rip), %rsi      # 0x84a8
callq 0x22d0
cmpl $0x0, %eax
jne 0x48d4
movq 0x30(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x48f3
leaq 0x3c4c(%rip), %rdi      # 0x8527
leaq 0x3b5a(%rip), %rsi      # 0x843c
movl $0x76, %edx
leaq 0x3bc0(%rip), %rcx      # 0x84ae
callq 0x2160
jmp 0x48f5
jmp 0x48f7
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x47da
addq $0x68, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	ska::flat_hash_map<uint32_t, uint32_t, Hash32> h;
	h.max_load_factor(0.75f);
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.insert(std::pair<uint32_t, uint32_t>(get_key(n, x), i));
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xd8, %rsp
movl %edi, 0xd4(%rsp)
movl %esi, 0xd0(%rsp)
movl $0x0, 0xc4(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x18b0
movq 0x48(%rsp), %rdi
movss 0x1979(%rip), %xmm0     # 0x3028
callq 0x18c0
jmp 0x16b6
movl $0x0, 0xcc(%rsp)
movl 0xd0(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xcc(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jae 0x1813
movl 0xc8(%rsp), %edi
callq 0x1310
movl %eax, 0x44(%rsp)
jmp 0x16f5
movl 0x44(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xd4(%rsp), %edi
movl 0xc8(%rsp), %esi
callq 0x1380
movl %eax, 0x40(%rsp)
jmp 0x1719
movl 0x40(%rsp), %eax
movl %eax, 0x74(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x74(%rsp), %rsi
leaq 0xcc(%rsp), %rdx
callq 0x1930
jmp 0x173a
leaq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x18e0
movb %dl, 0x37(%rsp)
movq %rax, 0x38(%rsp)
jmp 0x1757
movb 0x37(%rsp), %al
movq 0x38(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movb %al, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movb 0x68(%rsp), %al
movb %al, 0x88(%rsp)
movb 0x88(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17fb
leaq 0x80(%rsp), %rdi
callq 0x1a20
movq %rax, 0x28(%rsp)
jmp 0x17a6
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x1960
movq %rax, 0x20(%rsp)
jmp 0x17c9
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x17fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a60
jmp 0x188b
jmp 0x17fd
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x16cf
movq 0x37c6(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a50
movq %rax, 0x18(%rsp)
jmp 0x1836
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movl 0xc4(%rsp), %ecx
leaq 0x1857(%rip), %rsi      # 0x30a5
xorl %eax, %eax
callq 0x1110
leaq 0xa0(%rsp), %rdi
callq 0x1a50
movq %rax, 0x8(%rsp)
jmp 0x1869
movq 0x8(%rsp), %rax
movl %eax, 0x4(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a60
movl 0x4(%rsp), %eax
addq $0xd8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x1130
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::erase(ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::templated_iterator<std::pair<unsigned int, unsigned int> const>)
convertible_to_iterator erase(const_iterator to_erase)
    {
        EntryPointer current = to_erase.current;
        current->destroy_value();
        --num_elements;
        for (EntryPointer next = current + ptrdiff_t(1); !next->is_at_desired_position(); ++current, ++next)
        {
            current->emplace(next->distance_from_desired - 1, std::move(next->value));
            next->destroy_value();
        }
        return { to_erase.current };
    }

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1c00
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x19bd
jmp 0x1a06
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x1, %eax
movq 0x10(%rsp), %rdx
addq $0x4, %rdx
movsbl %al, %esi
callq 0x24e0
movq 0x10(%rsp), %rdi
callq 0x1c00
movq 0x18(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x10(%rsp)
jmp 0x19ab
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::clear()
void clear()
    {
        for (EntryPointer it = entries, end = it + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups); it != end; ++it)
        {
            if (it->has_value())
                it->destroy_value();
        }
        num_elements = 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rdx), %rcx
movsbq 0x11(%rdx), %rdx
addq %rdx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x1b30
movq 0x18(%rsp), %rdi
callq 0x1be0
testb $0x1, %al
jne 0x1b14
jmp 0x1b1e
movq 0x18(%rsp), %rdi
callq 0x1c00
jmp 0x1b20
movq 0x18(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x18(%rsp)
jmp 0x1af8
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: std::pair<ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::templated_iterator<std::pair<unsigned int, unsigned int>>, bool> ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::emplace<std::pair<unsigned int, unsigned int>>(std::pair<unsigned int, unsigned int>&&)
std::pair<iterator, bool> emplace(Key && key, Args &&... args)
    {
        size_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
        EntryPointer current_entry = entries + ptrdiff_t(index);
        int8_t distance_from_desired = 0;
        for (; current_entry->distance_from_desired >= distance_from_desired; ++current_entry, ++distance_from_desired)
        {
            if (compares_equal(key, current_entry->value))
                return { { current_entry }, false };
        }
        return emplace_new_key(distance_from_desired, current_entry, std::forward<Key>(key), std::forward<Args>(args)...);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
callq 0x1fe0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1fb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq (%rax), %rax
imulq $0xc, 0x40(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
movsbl 0x37(%rsp), %ecx
cmpl %ecx, %eax
jl 0x1f6a
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq $0x4, %rdx
callq 0x2010
testb $0x1, %al
jne 0x1f24
jmp 0x1f4e
movq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2040
movb $0x0, 0x27(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x27(%rsp), %rdx
callq 0x2060
jmp 0x1f9e
jmp 0x1f50
movq 0x38(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x38(%rsp)
movb 0x37(%rsp), %al
addb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x1ef5
movq 0x8(%rsp), %rdi
movsbl 0x37(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x2090
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x60(%rsp)
movq 0x58(%rsp), %rax
movb 0x60(%rsp), %dl
addq $0x68, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::reset_to_empty_state()
void reset_to_empty_state()
    {
        deallocate_data(entries, num_slots_minus_one, max_lookups);
        entries = Entry::empty_default_table();
        num_slots_minus_one = 0;
        hash_policy.reset();
        max_lookups = detailv3::min_lookups - 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rax, %rdi
movsbl 0x11(%rax), %ecx
callq 0x1b60
callq 0x1c10
movq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x2a50
movq 0x8(%rsp), %rax
movb $0x3, 0x11(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::next_power_of_two(unsigned long)
inline size_t next_power_of_two(size_t i)
{
    --i;
    i |= i >> 1;
    i |= i >> 2;
    i |= i >> 4;
    i |= i >> 8;
    i |= i >> 16;
    i |= i >> 32;
    ++i;
    return i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::log2(unsigned long)
inline int8_t log2(size_t value)
{
    static constexpr int8_t table[64] =
    {
        63,  0, 58,  1, 59, 47, 53,  2,
        60, 39, 48, 27, 54, 33, 42,  3,
        61, 51, 37, 40, 49, 18, 28, 20,
        55, 30, 34, 11, 43, 14, 22,  4,
        62, 57, 46, 52, 38, 26, 32, 41,
        50, 36, 17, 19, 29, 10, 13, 21,
        56, 45, 25, 31, 35, 16,  9, 12,
        44, 24, 15,  8, 23,  7,  6,  5
    };
    value |= value >> 1;
    value |= value >> 2;
    value |= value >> 4;
    value |= value >> 8;
    value |= value >> 16;
    value |= value >> 32;
    return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq -0x8(%rsp), %rax
shrq %rax
subq %rax, %rcx
movabsq $0x7edd5e59a4e28c2, %rax # imm = 0x7EDD5E59A4E28C2
imulq %rax, %rcx
shrq $0x3a, %rcx
leaq 0x531(%rip), %rax       # 0x30d0
movb (%rax,%rcx), %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lindorx[P]train/HelpInsPro.cpp
// Function: HexOct(char)
short HexOct(char ch)
{
	using namespace std;
	switch (ch){
	case '0':return 0;
	case '1':return 1;
	case '2':return 2;
	case '3':return 3;
	case '4':return 4;
	case '5':return 5;
	case '6':return 6;
	case '7':return 7;
	case '8':return 8;
	case '9':return 9;
	case 'a':return 10;
	case 'b':return 11;
	case 'c':return 12;
	case 'd':return 13;
	case 'e':return 14;
	case 'f':return 15;
	case 'A':return 10;
	case 'B':return 11;
	case 'C':return 12;
	case 'D':return 13;
	case 'E':return 14;
	case 'F':return 15;
	}
	std::cout << "HexOct����������error-003��\n" ;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x3(%rbp)
movsbl -0x3(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x36, %eax
ja 0x7553
movq -0x10(%rbp), %rax
leaq 0x13b91(%rip), %rcx     # 0x1b010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw $0x0, -0x2(%rbp)
jmp 0x756c
movw $0x1, -0x2(%rbp)
jmp 0x756c
movw $0x2, -0x2(%rbp)
jmp 0x756c
movw $0x3, -0x2(%rbp)
jmp 0x756c
movw $0x4, -0x2(%rbp)
jmp 0x756c
movw $0x5, -0x2(%rbp)
jmp 0x756c
movw $0x6, -0x2(%rbp)
jmp 0x756c
movw $0x7, -0x2(%rbp)
jmp 0x756c
movw $0x8, -0x2(%rbp)
jmp 0x756c
movw $0x9, -0x2(%rbp)
jmp 0x756c
movw $0xa, -0x2(%rbp)
jmp 0x756c
movw $0xb, -0x2(%rbp)
jmp 0x756c
movw $0xc, -0x2(%rbp)
jmp 0x756c
movw $0xd, -0x2(%rbp)
jmp 0x756c
movw $0xe, -0x2(%rbp)
jmp 0x756c
movw $0xf, -0x2(%rbp)
jmp 0x756c
movw $0xa, -0x2(%rbp)
jmp 0x756c
movw $0xb, -0x2(%rbp)
jmp 0x756c
movw $0xc, -0x2(%rbp)
jmp 0x756c
movw $0xd, -0x2(%rbp)
jmp 0x756c
movw $0xe, -0x2(%rbp)
jmp 0x756c
movw $0xf, -0x2(%rbp)
jmp 0x756c
movq 0x19a7e(%rip), %rdi     # 0x20fd8
leaq 0x13cb3(%rip), %rsi     # 0x1b214
callq 0x31f0
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lindorx[P]train/HelpInsPro.cpp
// Function: NumToUc(long, int)
std::vector<unsigned char>NumToUc(long n,int num)
{
	std::vector<unsigned char>data;
	for (int i = 0; i<num; i++){
		data.push_back((unsigned char)(n >> (8 * i)));
	}
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xa8d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7669
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movb -0x1c(%rbp), %cl
shlb $0x3, %cl
sarq %cl, %rax
movb %al, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0xa8f0
jmp 0x7645
jmp 0x7647
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x761e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa920
jmp 0x7686
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x767c
movq -0x40(%rbp), %rdi
callq 0xa920
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33f0
nop
// File: lindorx[P]train/HelpInsPro.cpp
// Function: FoundMathChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char FoundMathChar(const std::string& str)
{
	for (int i = 0; i < (int)str.size(); ++i){
		switch (str[i]){
		case '+':return '+';
		case '-':return '-';
		case '*':return '*';
		case '/':return '/';
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x7713
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
addl $-0x2a, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x7706
movq -0x20(%rbp), %rax
leaq 0x13a07(%rip), %rcx     # 0x1b0ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x2b, -0x1(%rbp)
jmp 0x7717
movb $0x2d, -0x1(%rbp)
jmp 0x7717
movb $0x2a, -0x1(%rbp)
jmp 0x7717
movb $0x2f, -0x1(%rbp)
jmp 0x7717
jmp 0x7708
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76a3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: lindorx[P]train/InsPro.cpp
// Function: MOVE(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
std::vector<unsigned char>MOVE(const std::string& str, int k, int num)
{
	using namespace std;
	int str_size = str.size();
	string *ch;//ch1��ch2�ֱ��������涺��ǰ�����ַ�����DEST �� SRC��
	//�����ո�
	while (k < str_size && (str[k] == 0x20 || str[k] == '\t'))k++;
	ch = CS(str, k);//���涺��ǰ�������ַ���
	STRINF *m1 = hep(ch[0]);
	STRINF *m2 = hep(ch[1]);
	
	if (!m1->w && !m2->w){
		//û������ʱ����Move1����Ҫ��һЩ������������
		if ((m1->explain == "byte" || m1->explain == "BYTE") && (m2->explain == "word" || m2->explain == "WORD"))cout << "���棬����ʹ��word�����򽫶�����������,���������룺" << str << endl;
		return Move1(m1, m2, num);
	}//������ʱ����Move2
	return Move2(str, m1, m2, num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x49(%rbp)
jge 0x10cb3
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x4a(%rbp)
je 0x10cad
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x10cbc
jmp 0x10cc7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10c6d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6a20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa380
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0xa380
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x40(%rax)
jne 0x10da9
movq -0x38(%rbp), %rax
testb $0x1, 0x40(%rax)
jne 0x10da9
movq -0x30(%rbp), %rdi
leaq 0xa987(%rip), %rsi      # 0x1b6a3
callq 0xa8a0
testb $0x1, %al
jne 0x10d3b
movq -0x30(%rbp), %rdi
leaq 0xa503(%rip), %rsi      # 0x1b233
callq 0xa8a0
testb $0x1, %al
jne 0x10d3b
jmp 0x10d93
movq -0x38(%rbp), %rdi
leaq 0xa528(%rip), %rsi      # 0x1b26e
callq 0xa8a0
testb $0x1, %al
jne 0x10d65
movq -0x38(%rbp), %rdi
leaq 0xa519(%rip), %rsi      # 0x1b273
callq 0xa8a0
testb $0x1, %al
jne 0x10d65
jmp 0x10d93
movq 0x1026c(%rip), %rdi     # 0x20fd8
leaq 0xa728(%rip), %rsi      # 0x1b49b
callq 0x31f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
movq 0x10232(%rip), %rsi     # 0x20fc0
callq 0x3240
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq 0xcf80
jmp 0x10dc2
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %r8d
callq 0xd860
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: lindorx[P]train/InsPro.cpp
// Function: Int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int)
std::vector<unsigned char>Int(std::string& str,int n,int num)
{
	using namespace std;
	vector<unsigned char>data;
	vector<unsigned char>d;
	data.push_back(0xcd);
	str = CutStr(str, n);
	d = Num(str, 1, num);
	data.push_back(d[0]);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa8d0
leaq -0x38(%rbp), %rdi
callq 0xa8d0
movq -0x90(%rbp), %rdi
movb $-0x33, -0x39(%rbp)
leaq -0x39(%rbp), %rsi
callq 0xa8f0
jmp 0x137b2
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0x67d0
jmp 0x137c4
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x32c0
movq -0xa0(%rbp), %rdi
callq 0x3468
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %ecx
leaq -0x88(%rbp), %rdi
movl $0x1, %edx
callq 0x7be0
jmp 0x137fe
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x88(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xa9b0
movq -0xb0(%rbp), %rdi
callq 0xa920
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaa70
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0xaa00
jmp 0x13849
movb $0x1, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa920
testb $0x1, -0x19(%rbp)
jne 0x1388d
jmp 0x13881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa920
movq -0x90(%rbp), %rdi
callq 0xa920
jmp 0x1389d
movq -0x90(%rbp), %rdi
callq 0xa920
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: lindorx[P]train/InsPro.cpp
// Function: Not(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::vector<unsigned char>Not(const std::string& str, int n)
{
	using namespace std;
	string ch = CutStr(str, n);
	vector<unsigned char>data;
	for (int i = 0; i < 16; ++i){
		if (ch == reg_1[i]){
			data.push_back(0xf6);
			if (i>7)data.push_back(logic_not[i - 8]);
			else data.push_back(logic_not[8]);
			return data;
		}
		if (ch == reg2[i]){
			data.push_back(0xf7);
			if (i>7)data.push_back(logic_not[i - 8]);
			else data.push_back(logic_not[8]);
			return data;
		}
	}
	cout << "����-026������������:" << str << endl;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0x67d0
movq -0x68(%rbp), %rdi
movb $0x0, -0x39(%rbp)
callq 0xa8d0
movl $0x0, -0x40(%rbp)
cmpl $0x10, -0x40(%rbp)
jge 0x14e79
movslq -0x40(%rbp), %rax
leaq 0xce26(%rip), %rsi      # 0x21b80
shlq $0x5, %rax
addq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xa810
testb $0x1, %al
jne 0x14d70
jmp 0x14def
movq -0x68(%rbp), %rdi
movb $-0xa, -0x41(%rbp)
leaq -0x41(%rbp), %rsi
callq 0xa8f0
jmp 0x14d83
cmpl $0x7, -0x40(%rbp)
jle 0x14dcb
movq -0x68(%rbp), %rdi
movl -0x40(%rbp), %eax
addl $-0x8, %eax
cltq
leaq 0x68bf(%rip), %rsi      # 0x1b65b
addq %rax, %rsi
callq 0xaa00
jmp 0x14da6
jmp 0x14ddf
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0xa920
leaq -0x38(%rbp), %rdi
callq 0x3468
jmp 0x14ee7
movq -0x68(%rbp), %rdi
leaq 0x688d(%rip), %rsi      # 0x1b663
callq 0xaa00
jmp 0x14ddd
jmp 0x14ddf
movb $0x1, -0x39(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x14ec2
movslq -0x40(%rbp), %rax
leaq 0xcf86(%rip), %rsi      # 0x21d80
shlq $0x5, %rax
addq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xa810
testb $0x1, %al
jne 0x14e10
jmp 0x14e69
movq -0x68(%rbp), %rdi
movb $-0x9, -0x59(%rbp)
leaq -0x59(%rbp), %rsi
callq 0xa8f0
jmp 0x14e23
cmpl $0x7, -0x40(%rbp)
jle 0x14e48
movq -0x68(%rbp), %rdi
movl -0x40(%rbp), %eax
addl $-0x8, %eax
cltq
leaq 0x681f(%rip), %rsi      # 0x1b65b
addq %rax, %rsi
callq 0xaa00
jmp 0x14e46
jmp 0x14e5c
movq -0x68(%rbp), %rdi
leaq 0x6810(%rip), %rsi      # 0x1b663
callq 0xaa00
jmp 0x14e5a
jmp 0x14e5c
movb $0x1, -0x39(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x14ec2
jmp 0x14e6b
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x14d45
movq 0xc158(%rip), %rdi      # 0x20fd8
leaq 0x6714(%rip), %rsi      # 0x1b59b
callq 0x31f0
movq %rax, -0x78(%rbp)
jmp 0x14e92
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31e0
movq %rax, -0x80(%rbp)
jmp 0x14ea5
movq -0x80(%rbp), %rdi
movq 0xc110(%rip), %rsi      # 0x20fc0
callq 0x3240
jmp 0x14eb7
movb $0x1, -0x39(%rbp)
movl $0x1, -0x58(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x14ed1
movq -0x68(%rbp), %rdi
callq 0xa920
leaq -0x38(%rbp), %rdi
callq 0x3468
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33f0
// File: lindorx[P]train/main.cpp
// Function: FileOut()
void FileOut(void)
{
	using namespace std;
	std::ofstream fout(fout_src, std::ios::binary);
	if (!fout.is_open())cout << endl << "�ļ�д��ʧ��!" << endl;
	for (int i = 0; i < (int)Data.size(); i++) {
		fout.put(Data[i]);
	}
	fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
leaq 0x9576(%rip), %rsi      # 0x220c8
leaq -0x200(%rbp), %rdi
movq %rdi, -0x220(%rbp)
movl $0x4, %edx
callq 0x3430
movq -0x220(%rbp), %rdi
callq 0x3180
movb %al, -0x211(%rbp)
jmp 0x18b7e
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x18bfc
jmp 0x18b8a
movq 0x8447(%rip), %rdi      # 0x20fd8
movq 0x8428(%rip), %rsi      # 0x20fc0
callq 0x3240
movq %rax, -0x228(%rbp)
jmp 0x18ba6
movq -0x228(%rbp), %rdi
leaq 0x2c70(%rip), %rsi      # 0x1b824
callq 0x31f0
movq %rax, -0x230(%rbp)
jmp 0x18bc2
movq -0x230(%rbp), %rdi
movq 0x83f0(%rip), %rsi      # 0x20fc0
callq 0x3240
jmp 0x18bd7
jmp 0x18bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x3360
jmp 0x18c85
movl $0x0, -0x210(%rbp)
movl -0x210(%rbp), %eax
movl %eax, -0x234(%rbp)
leaq 0x9477(%rip), %rdi      # 0x22090
callq 0xa9e0
movq %rax, %rcx
movl -0x234(%rbp), %eax
cmpl %ecx, %eax
jge 0x18c62
movslq -0x210(%rbp), %rsi
leaq 0x9457(%rip), %rdi      # 0x22090
callq 0xaa70
movsbl (%rax), %esi
leaq -0x200(%rbp), %rdi
callq 0x3040
jmp 0x18c4f
jmp 0x18c51
movl -0x210(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x210(%rbp)
jmp 0x18c06
leaq -0x200(%rbp), %rdi
callq 0x3340
jmp 0x18c70
leaq -0x200(%rbp), %rdi
callq 0x3360
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x208(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: lindorx[P]train/main.cpp
// Function: CutStrCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string CutStrCode(const std::string& str, int num = 0)//�ж��Ƿ����б��ţ�û���򷵻�ָ���ַ���
{
	using namespace std;
	std::string m;
	//��ȥ��ͷ���ֿ��ܴ��ڵ��޹��ַ���0x20Ϊ�ո�
	while (num < (int)str.size()) {
		if (str[num] != 0x20 && str[num] != '\t' && str[num] != ',')break;
		num++;
	}
	//��ȡ�ַ���
	while (num < (int)str.size() && (isalnum(str[num]) || str[num] == '$' || str[num] == ':' || str[num] == '_')) {
		if (str[num] == ':') {
			is_Title = true;
			break;
		}
		m.push_back(str[num]); num++;
	}
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x3330
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x18d2c
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x18d21
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x18d21
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x18d21
jmp 0x18d2c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18cc7
jmp 0x18d2e
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movl -0x44(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3d(%rbp)
jge 0x18dbf
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %edi
callq 0x3220
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x45(%rbp)
jne 0x18db9
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x24, %ecx
movb %al, -0x45(%rbp)
je 0x18db9
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3a, %ecx
movb %al, -0x45(%rbp)
je 0x18db9
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x18dc8
jmp 0x18e26
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x18de6
movb $0x1, 0x93d4(%rip)      # 0x221b8
jmp 0x18e26
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x31c0
jmp 0x18e01
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18d2e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3468
jmp 0x18e43
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x18e39
movq -0x38(%rbp), %rdi
callq 0x3468
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: lindorx[P]train/main.cpp
// Function: DataChar(int, unsigned char)
void DataChar(int n, unsigned char ch)
{
	using namespace std;
	if (n > 0) {
		Data.insert(Data.end(), n, ch);
		FileSize += n;
		Number += n;
	}
	else if (n < 0) {
		cout << "����-027����������resbָ��������������������С��0" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x18f70
leaq 0x9172(%rip), %rdi      # 0x22090
callq 0xab40
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xab70
movslq -0x4(%rbp), %rdx
movq -0x10(%rbp), %rsi
leaq 0x914d(%rip), %rdi      # 0x22090
leaq -0x5(%rbp), %rcx
callq 0x156c0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl 0x912b(%rip), %eax      # 0x22084
movl %eax, 0x9125(%rip)      # 0x22084
movl -0x4(%rbp), %eax
addl 0x9120(%rip), %eax      # 0x22088
movl %eax, 0x911a(%rip)      # 0x22088
jmp 0x18f9a
cmpl $0x0, -0x4(%rbp)
jge 0x18f98
movq 0x805b(%rip), %rdi      # 0x20fd8
leaq 0x28ae(%rip), %rsi      # 0x1b832
callq 0x31f0
movq %rax, %rdi
movq 0x802d(%rip), %rsi      # 0x20fc0
callq 0x3240
jmp 0x18f9a
addq $0x20, %rsp
popq %rbp
retq