LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_free
static void gt_sort_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  for (i = sort_stream->idx; i < gt_array_size(sort_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(sort_stream->nodes, i));
  }
  gt_array_delete(sort_stream->nodes);
  gt_node_stream_delete(sort_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x29cec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x292d4
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rax), %rdi
callq 0x422ee
cmpq %rax, %r14
jae 0x29d72
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x4200e
movq (%rax), %rdi
callq 0x220ee
incq %r14
movq 0x20(%rbx), %rdi
jmp 0x29d4b
movq 0x20(%rbx), %rdi
callq 0x42748
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x290de
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_new
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true);
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  gt_assert(in_stream);
  sort_stream->in_stream = gt_node_stream_ref(in_stream);
  sort_stream->sorted = false;
  sort_stream->idx = 0;
  sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x29cec
movq %rax, %rdi
movl $0x1, %esi
callq 0x2905c
movq %rax, %rbx
callq 0x29cec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x292d4
testq %r14, %r14
je 0x2a00c
movq %rax, %r15
movq %r14, %rdi
callq 0x290c8
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
movq $0x0, 0x18(%r15)
movl $0x8, %edi
callq 0x41f50
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe2ce
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: countint
static int countint (const TValue *key, int *nums) {
  int k = arrayindex(key);
  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
    nums[ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
cmpl $0x3, 0x8(%rdi)
jne 0x32b23
movsd (%rdi), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x32b23
jnp 0x32b73
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
decl %ecx
xorl %eax, %eax
cmpl $0x3ffffff, %ecx        # imm = 0x3FFFFFF
ja 0x32b72
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x100, %ecx            # imm = 0x100
jb 0x32b55
movl %ecx, %edx
addl $0x8, %eax
shrl $0x8, %edx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl %edx, %ecx
ja 0x32b43
jmp 0x32b57
movl %ecx, %edx
movl %edx, %ecx
leaq 0x4fef0(%rip), %rdx     # 0x82a50
movzbl (%rcx,%rdx), %ecx
cltq
addq %rcx, %rax
incl 0x4(%rsi,%rax,4)
movl $0x1, %eax
retq
cvttsd2si %xmm0, %ecx
jmp 0x32b28
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: printWithEscapeCharacters
void printWithEscapeCharacters(FILE *out, char *message) {
    unsigned int index = 0;
    char currentCharacter = message[index];

    while (currentCharacter != '\0') {
        switch (currentCharacter) {
        case '\r':
            fputc('\\', out);
            fputc('r', out);
            break;
        case '\n':
            fputc('\\', out);
            fputc('n', out);
            break;
        case '\t':
            fputc('\\', out);
            fputc('t', out);
            break;
        default :
            fputc(currentCharacter, out);
            break;
        }

    index += 1;
    currentCharacter = message[index];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r15d
movq %rsi, %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jle 0x1415
cmpl $0xa, %eax
je 0x142b
cmpl $0xd, %eax
jne 0x1443
movl $0x5c, %edi
movq %r14, %rsi
callq 0x1100
movl $0x72, %edi
jmp 0x1446
jne 0x143f
movl $0x5c, %edi
movq %r14, %rsi
callq 0x1100
movl $0x74, %edi
jmp 0x1446
movl $0x5c, %edi
movq %r14, %rsi
callq 0x1100
movl $0x6e, %edi
jmp 0x1446
testl %eax, %eax
je 0x1459
movsbl %al, %edi
movq %r14, %rsi
callq 0x1100
movl %r15d, %eax
addq %rbx, %rax
incl %r15d
jmp 0x13ef
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: setupServer
int setupServer(ConfigurationRef config) {
    int socketNumber = 0;
    int status = 0;
    struct sockaddr_in configuration = (const struct sockaddr_in){0};

    socketNumber = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketNumber < 0) {
        exitWithError("setupServer: unable to obtain socket for server",
            EC_SOCKET_FAILURE);
    }

    memset(&configuration, 0, sizeof(configuration));
    configuration.sin_family = AF_INET;
    configuration.sin_addr.s_addr = htonl(INADDR_ANY);
    configuration.sin_port = htons(configPort(config));

    status = bind(socketNumber, (struct sockaddr*)&configuration, sizeof(configuration));
    if (status < 0) {
        exitWithError("setupServer: socket could not be bound with configuration",
            EC_BIND_FAILURE);
    }

    status = listen(socketNumber, BACKLOG_SIZE);
    if (status < 0) {
        exitWithError("setupServer: unable to configure server listening",
            EC_LISTEN_FAILURE);
    }

    return socketNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x11f0
testl %eax, %eax
js 0x1507
movl %eax, %ebx
leaq -0x30(%rbp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movw $0x2, (%r15)
movl $0x0, 0x4(%r15)
movq %r14, %rdi
callq 0x1a0a
rolw $0x8, %ax
movw %ax, 0x2(%r15)
movl %ebx, %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x1170
testl %eax, %eax
js 0x150c
movl %ebx, %edi
movl $0x5, %esi
callq 0x1150
testl %eax, %eax
js 0x1511
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1286
callq 0x125b
callq 0x1230
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: handleClientRequest
void handleClientRequest(int clientSocket, char* request) {
    printf("received message:\n");

    printWithEscapeCharacters(stdout, request);
    printf("\n");

    printf("\n");

    printf("sent message:\n");

    send(clientSocket, defaultHeader, strlen(defaultHeader), 0);
    printWithEscapeCharacters(stdout, defaultHeader);
    printf("\n");

    send(clientSocket, defaultBody, strlen(defaultBody), 0);
    printWithEscapeCharacters(stdout, defaultBody);
    printf("\n");

    printf("\n");

    CLOSESOCKET(clientSocket);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0xfc68(%rip), %rdi      # 0x11194
callq 0x1070
movq 0x14a98(%rip), %r15     # 0x15fd0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
leaq 0xfc48(%rip), %rdi      # 0x111a6
callq 0x1070
movq 0x14ba6(%rip), %r14     # 0x16110
movq %r14, %rdi
callq 0x10b0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10c0
movq (%r15), %rdi
movq 0x14b85(%rip), %rsi     # 0x16110
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movq 0x14b77(%rip), %r14     # 0x16118
movq %r14, %rdi
callq 0x10b0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10c0
movq (%r15), %rdi
movq 0x14b56(%rip), %rsi     # 0x16118
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: main
int main(int argc, char **argv) {
    int serverSocket = 0;
    int clientSocket = 0;
    int receivedCharacters = 0;
    char messageBuffer[BUFFER_SIZE];
    ConfigurationRef config = configCreate();

    checkArguments(argc, argv, config);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
      if (status != 0) {
          exitWithError("main: could not perform startup on Windows",
              EC_WSASTARTUP_FAILURE);
      }
    #endif

    serverSocket = setupServer(config);

    printf("awaiting client connections...\n\n");

    while (1) {
        clientSocket = accept(serverSocket, NULL, NULL);
        printf("client connected!\n\n");

        receivedCharacters = recv(clientSocket, messageBuffer, BUFFER_SIZE, 0);
        if (receivedCharacters < 1) {
            printf("---ERROR RETRIEVING CLIENT REQUEST---\n");
            if (receivedCharacters == 0) printf(" -client already shutdown\n");
            if (receivedCharacters < 0) printf(" -socket error, check errno\n");
            //CLOSESOCKET(clientSocket);
            continue;
        }

        handleClientRequest(clientSocket, messageBuffer);
    }

    CLOSESOCKET(serverSocket);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      WSACleanup();
    #endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r14
movl %edi, %r15d
callq 0x16b4
movq %rax, %rbx
cmpl $0x3, %r15d
jl 0x1620
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x192d
movq %rbx, %rdi
callq 0x147c
movl %eax, %ebx
leaq 0xfb83(%rip), %rdi      # 0x111b4
callq 0x1070
leaq 0xfb97(%rip), %r14      # 0x111d4
leaq -0x1030(%rbp), %r15
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11a0
movl %eax, %r13d
movq %r14, %rdi
callq 0x1070
movl $0x1000, %edx           # imm = 0x1000
movl %r13d, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1040
movq %rax, %r12
testl %r12d, %r12d
jle 0x1681
movl %r13d, %edi
movq %r15, %rsi
callq 0x1516
jmp 0x1644
leaq 0xfb5f(%rip), %rdi      # 0x111e7
callq 0x1070
testl %r12d, %r12d
jne 0x169e
leaq 0xfb74(%rip), %rdi      # 0x1120d
callq 0x1070
testl %r12d, %r12d
jns 0x1644
leaq 0xfb7d(%rip), %rdi      # 0x11227
callq 0x1070
jmp 0x1644
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/config.c
// Function: configCreate
ConfigurationRef configCreate() {
    ConfigurationRef config = malloc(sizeof(struct Configuration));
    if (config != NULL) {
        config->port = 8080;
    }

    return config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
callq 0x1140
testq %rax, %rax
je 0x16cc
movw $0x1f90, (%rax)         # imm = 0x1F90
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadDocument
enum ConfigurationStatus _configLoadDocument(ConfigurationRef config, yaml_document_t *document) {
    enum ConfigurationStatus status = CONFIG_SUCCESS;

    yaml_node_t *rootNode =  yaml_document_get_root_node(document);
    if (rootNode->type == YAML_MAPPING_NODE) {

        yaml_node_pair_t *pair = rootNode->data.mapping.pairs.start;
        for (; pair != rootNode->data.mapping.pairs.top; pair++) {
            yaml_node_t *keyNode = yaml_document_get_node(document, pair->key);
            yaml_node_t *valueNode = yaml_document_get_node(document, pair->value);
            
            status = configSetOption(
                config,
                (const char *)keyNode->data.scalar.value,
                (const char *)valueNode->data.scalar.value);

            if (status != CONFIG_SUCCESS) {
                break;
            }
        }
    }
    else {
        status = CONFIG_INVALID_ROOT_ERROR;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c06
movq %rax, %r15
movl $0x3, %eax
cmpl $0x3, (%r15)
jne 0x176c
movq 0x10(%r15), %r13
cmpq 0x20(%r15), %r13
je 0x176a
movl (%r13), %esi
movq %rbx, %rdi
callq 0x3bb9
movq %rax, %r12
movl 0x4(%r13), %esi
movq %rbx, %rdi
callq 0x3bb9
movq 0x10(%r12), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x177b
testl %eax, %eax
jne 0x176c
addq $0x8, %r13
cmpq 0x20(%r15), %r13
jne 0x172e
jmp 0x176c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/config.c
// Function: configSetOption
enum ConfigurationStatus configSetOption(ConfigurationRef config, const char *name, const char *value) {
    assert(config != NULL);
    assert(name != NULL);
    assert(value != NULL);

    // ideally should use some sort of mapping
    if (strcmp(name, "port") == 0) {
        
        errno = 0;
        unsigned short portNumber = (unsigned short)strtoul(value, NULL, 10);

        if (errno == EINVAL || errno == ERANGE) {
            return CONFIG_INVALID_VALUE_ERROR;
        }
        config->port = portNumber;

    } 
    else {
        return CONFIG_NO_SUCH_OPTION_ERROR;
    }

    return CONFIG_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1803
testq %rsi, %rsi
je 0x1822
movq %rdx, %r14
testq %rdx, %rdx
je 0x1841
movq %rdi, %rbx
leaq 0xfc00(%rip), %rax      # 0x113a9
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1110
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x17ca
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
movq %rax, %r15
movl $0x0, (%rax)
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x11b0
movq %rax, %rcx
movl (%r15), %edx
movl $0x2, %eax
cmpl $0x16, %edx
je 0x17bf
cmpl $0x22, %edx
je 0x17bf
movw %cx, (%rbx)
xorl %eax, %eax
jmp 0x17bf
leaq 0xfa39(%rip), %rdi      # 0x11243
leaq 0xfa41(%rip), %rsi      # 0x11252
leaq 0xfb1f(%rip), %rcx      # 0x11337
movl $0x73, %edx
callq 0x10d0
leaq 0xfb65(%rip), %rdi      # 0x1138e
leaq 0xfa22(%rip), %rsi      # 0x11252
leaq 0xfb00(%rip), %rcx      # 0x11337
movl $0x74, %edx
callq 0x10d0
leaq 0xfb53(%rip), %rdi      # 0x1139b
leaq 0xfa03(%rip), %rsi      # 0x11252
leaq 0xfae1(%rip), %rcx      # 0x11337
movl $0x75, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadString
enum ConfigurationStatus configLoadString(ConfigurationRef config, const char *inputString) {
    assert(config != NULL);
    assert(inputString != NULL);

    enum ConfigurationStatus status = CONFIG_SUCCESS;
    int inputLength = strlen(inputString);
    yaml_parser_t parser;
    yaml_document_t document;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_string(&parser, (const unsigned char *)inputString, inputLength);
    yaml_parser_load(&parser, &document);

    status = _configLoadDocument(config, &document);

    yaml_parser_delete(&parser);
    yaml_document_delete(&document);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
testq %rdi, %rdi
je 0x18ef
movq %rsi, %r14
testq %rsi, %rsi
je 0x190e
movq %rdi, %rbx
movq %r14, %rdi
callq 0x10b0
movq %rax, %r15
leaq -0x268(%rbp), %r12
movq %r12, %rdi
callq 0x1c40
movslq %r15d, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x217b
leaq -0x88(%rbp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x42b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16fa
movl %eax, %ebx
movq %r12, %rdi
callq 0x1f3d
movq %r14, %rdi
callq 0x3a9a
movl %ebx, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf94d(%rip), %rdi      # 0x11243
leaq 0xf955(%rip), %rsi      # 0x11252
leaq 0xf97c(%rip), %rcx      # 0x11280
movl $0x3f, %edx
callq 0x10d0
leaq 0xf9b5(%rip), %rdi      # 0x112ca
leaq 0xf936(%rip), %rsi      # 0x11252
leaq 0xf95d(%rip), %rcx      # 0x11280
movl $0x40, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadFile
enum ConfigurationStatus configLoadFile(ConfigurationRef config, const char *filepath) {
    assert(config != NULL);
    assert(filepath != NULL);

    enum ConfigurationStatus status = CONFIG_SUCCESS;
    yaml_parser_t parser;
    yaml_document_t document;

    FILE *file = fopen(filepath, "r");
    
    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);
    yaml_parser_load(&parser, &document);

    status = _configLoadDocument(config, &document);

    fclose(file);
    yaml_parser_delete(&parser);
    yaml_document_delete(&document);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
testq %rdi, %rdi
je 0x19cc
testq %rsi, %rsi
je 0x19eb
movq %rdi, %rbx
leaq 0x11352(%rip), %rax     # 0x12cad
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1190
movq %rax, %r14
leaq -0x268(%rbp), %r15
movq %r15, %rdi
callq 0x1c40
movq %r15, %rdi
movq %r14, %rsi
callq 0x2251
leaq -0x88(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x42b4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16fa
movl %eax, %ebx
movq %r14, %rdi
callq 0x10a0
movq %r15, %rdi
callq 0x1f3d
movq %r12, %rdi
callq 0x3a9a
movl %ebx, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf870(%rip), %rdi      # 0x11243
leaq 0xf878(%rip), %rsi      # 0x11252
leaq 0xf8fd(%rip), %rcx      # 0x112de
movl $0x54, %edx
callq 0x10d0
leaq 0xf934(%rip), %rdi      # 0x11326
leaq 0xf859(%rip), %rsi      # 0x11252
leaq 0xf8de(%rip), %rcx      # 0x112de
movl $0x55, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/openshmem-org[P]openshmem-examples/c/fadd.c
// Function: main
int
main()
{
    int me;
    int old;

    shmem_init();
    me = shmem_my_pe();

    old = -1;
    dst = 22;
    shmem_barrier_all();

    if (me == 1) {
        old = shmem_int_atomic_fetch_add(&dst, 44, 0);
    }
    shmem_barrier_all();

    printf("%d: old = %d, dst = %d\n", me, old, dst);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1070
callq 0x1050
movl %eax, %ebx
movl $0x16, 0x2eb7(%rip)     # 0x405c
callq 0x1060
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x1, %ebx
jne 0x11c9
leaq 0x2ea1(%rip), %rdi      # 0x405c
movl $0x2c, %esi
xorl %edx, %edx
callq 0x1080
movl %eax, %ebp
callq 0x1060
movl 0x2e88(%rip), %ecx      # 0x405c
leaq 0xe29(%rip), %rdi       # 0x2004
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1030
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/examples/noop.c
// Function: main
int main(GT_UNUSED int argc, GT_UNUSED char *argv[])
{
  gt_lib_init();
  if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
    fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
                                                    GT_MINOR_VERSION,
                                                    GT_MICRO_VERSION));
    return EXIT_FAILURE;
  }

  if (gt_lib_clean())
    return GT_EXIT_PROGRAMMING_ERROR; /* programmer error */
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
callq 0xb57c
movl $0x1, %ebx
movl $0x1, %edi
movl $0x6, %esi
movl $0x6, %edx
callq 0x1383c
testq %rax, %rax
jne 0xb572
callq 0xb7ab
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
addl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
callq 0x46b0
jmp 0xb56e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/version.c
// Function: gt_version_check
const char* gt_version_check(unsigned int required_major,
                             unsigned int required_minor,
                             unsigned int required_micro)
{
  if (required_major > GT_MAJOR_VERSION)
    return "GenomeTools library version too old (major mismatch)";
  if (required_major < GT_MAJOR_VERSION)
    return "GenomeTools library version too new (major mismatch)";
  if (required_minor > GT_MINOR_VERSION)
    return "GenomeTools library version too old (minor mismatch)";
  if (required_micro > GT_MICRO_VERSION)
    return "GenomeTools library version too old (micro mismatch)";
  return NULL;
}

// Assembly:
cmpl $0x1, %edi
jbe 0x13849
leaq 0x2a463(%rip), %rax     # 0x3dcab
retq
testl %edi, %edi
je 0x1385a
cmpl $0x6, %esi
jbe 0x13862
leaq 0x2a4bc(%rip), %rax     # 0x3dd15
retq
leaq 0x2a47f(%rip), %rax     # 0x3dce0
retq
xorl %eax, %eax
cmpl $0x7, %edx
leaq 0x2a4dc(%rip), %rcx     # 0x3dd4a
cmovaeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/touch.c
// Function: main
int main(int argc, char **argv){
    if(argc == 1){
        fprintf(stderr, "%s: missing file operand\n", argv[0]);
        return 1;
    }
    for(int i = 1; argv[i] != NULL; i++){
        if(utime(argv[i], NULL) == -1){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x1207
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1200
leaq 0x10(%rbx), %r14
xorl %esi, %esi
callq 0x1030
cmpl $-0x1, %eax
je 0x1211
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x11e8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x10bb
jmp 0x1219
movq %rbx, %rdi
callq 0x1080
movl $0x1, %eax
jmp 0x1202
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/simple/example.c
// Function: prepare_inputs
void prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {
  randombytes(input_data, c->number_measurements * c->chunk_size);
  for (size_t i = 0; i < c->number_measurements; i++) {
    /* it is important to randomize the class sequence */
    classes[i] = randombit();
    if (classes[i] == 0) {
      memset(input_data + (size_t)i * c->chunk_size, 0x00, c->chunk_size);
    } else {
      // leave random
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rsi
imulq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x11fc
cmpq $0x0, 0x8(%r15)
je 0x1830
xorl %r13d, %r13d
leaq -0x29(%rbp), %r12
movb $0x0, -0x29(%rbp)
movl $0x1, %esi
movq %r12, %rdi
callq 0x11fc
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, (%rbx,%r13)
jne 0x1827
movq (%r15), %rdx
movq %rdx, %rdi
imulq %r13, %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x1090
incq %r13
cmpq 0x8(%r15), %r13
jb 0x17f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3av_reply *reply;
	int ret;

	if (fd < 0)
		return (-1);

	reply = (struct ps3av_reply *) tmp;

	while (1) {
		ret = read(fd, &reply->hdr, sizeof(reply->hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, &reply->cmd, reply->hdr.length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(reply->hdr) + reply->hdr.length))
		len = sizeof(reply->hdr) + reply->hdr.length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x2d6d(%rip)      # 0x4190
js 0x149e
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movl 0x2d5c(%rip), %edi      # 0x4190
movl $0x4, %edx
movq %r12, %rsi
callq 0x1070
testl %eax, %eax
js 0x1449
je 0x142e
jmp 0x1455
callq 0x1030
cmpl $0xb, (%rax)
je 0x142e
jmp 0x149e
leaq 0x4(%rsp), %r12
movl 0x2d30(%rip), %edi      # 0x4190
movzwl 0x2(%rsp), %edx
movq %r12, %rsi
callq 0x1070
testl %eax, %eax
js 0x1475
je 0x145a
jmp 0x1481
callq 0x1030
cmpl $0xb, (%rax)
je 0x145a
jmp 0x149e
movq %rsp, %rsi
movzwl 0x2(%rsi), %ebx
addq $0x4, %rbx
cmpq %r15, %rbx
cmovaeq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10a0
movl %ebx, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_get_hdcp_ksv.c
// Function: cmd_av_get_hdcp_ksv_exec
int
cmd_av_get_hdcp_ksv_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_request req;
	struct ps3av_av_get_hdcp_ksv_reply av_get_hdcp_ksv_reply;
	int ret;

	ps3av_init_request(&req, sizeof(req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_GET_HDCP_KSV);

	ret = dev_write(&req, sizeof(req));
	if (ret != sizeof(req))
		return (CMD_EIO);

	ret = dev_read(&av_get_hdcp_ksv_reply, sizeof(av_get_hdcp_ksv_reply));
	if (ret != sizeof(av_get_hdcp_ksv_reply))
		return (CMD_EIO);

	if (av_get_hdcp_ksv_reply.reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	fwrite(av_get_hdcp_ksv_reply.ksv, 1, av_get_hdcp_ksv_reply.ksv_length, stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movabsq $0xc00040205, %rax      # imm = 0xC00040205
leaq 0xc(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
callq 0x13e8
movl $0x3, %ebx
cmpl $0x8, %eax
jne 0x1514
leaq 0x14(%rsp), %rdi
movl $0x1c, %esi
callq 0x1409
cmpl $0x1c, %eax
jne 0x1514
cmpl $0x0, 0x1c(%rsp)
jne 0x1514
leaq 0x24(%rsp), %rdi
movl -0x4(%rdi), %edx
movq 0x2ac3(%rip), %rax      # 0x3fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x10f0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_get_hw_conf.c
// Function: cmd_av_get_hw_conf_exec
int
cmd_av_get_hw_conf_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_request req;
	struct ps3av_av_get_hw_conf_reply av_get_hw_conf_reply;
	int ret;

	ps3av_init_request(&req, sizeof(req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_GET_HW_CONF);

	ret = dev_write(&req, sizeof(req));
	if (ret != sizeof(req))
		return (CMD_EIO);

	ret = dev_read(&av_get_hw_conf_reply, sizeof(av_get_hw_conf_reply));
	if (ret != sizeof(av_get_hw_conf_reply))
		return (CMD_EIO);

	if (av_get_hw_conf_reply.reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	fprintf(stdout, "%d %d %d\n", av_get_hw_conf_reply.nr_hdmi,
	    av_get_hw_conf_reply.nr_avmulti, av_get_hw_conf_reply.nr_spdif);

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movabsq $0x300040205, %rax      # imm = 0x300040205
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
callq 0x13e8
movl $0x3, %ebx
cmpl $0x8, %eax
jne 0x158c
leaq 0x4(%rsp), %rdi
movl $0x14, %esi
callq 0x1409
cmpl $0x14, %eax
jne 0x158c
cmpl $0x0, 0xc(%rsp)
jne 0x158c
movq 0x2a5f(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movzwl 0x10(%rsp), %edx
movzwl 0x12(%rsp), %ecx
movzwl 0x14(%rsp), %r8d
leaq 0xba2(%rip), %rsi       # 0x2125
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1090
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_video_mute.c
// Function: cmd_av_video_mute_exec
int
cmd_av_video_mute_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_av_video_mute av_video_mute_req;
	struct ps3av_reply reply;
	char *endptr;
	unsigned int port, mute;
	int ret;

	port = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	mute = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	ps3av_init_request(PS3AV_REQ(&av_video_mute_req),
	    sizeof(av_video_mute_req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_VIDEO_MUTE);

	av_video_mute_req.port = port;
	av_video_mute_req.mute = mute;

	ret = dev_write(&av_video_mute_req, sizeof(av_video_mute_req));
	if (ret != sizeof(av_video_mute_req))
		return (CMD_EIO);

	ret = dev_read(&reply, sizeof(reply));
	if (ret != sizeof(reply))
		return (CMD_EIO);

	if (reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10d0
movq %rax, %r14
movq (%rbx), %rax
movl $0x2, %ebx
cmpb $0x0, (%rax)
jne 0x1775
movq 0x8(%r15), %rdi
movq %rsp, %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
jne 0x1775
movabsq $0x1000200080205, %rcx  # imm = 0x1000200080205
leaq 0x14(%rsp), %rdi
movq %rcx, (%rdi)
movw %r14w, 0x8(%rdi)
movw %ax, 0xa(%rdi)
movl $0xc, %esi
callq 0x13e8
movl $0x3, %ebx
cmpl $0xc, %eax
jne 0x1775
leaq 0x8(%rsp), %rdi
movl $0xc, %esi
callq 0x1409
cmpl $0xc, %eax
jne 0x1775
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_video_pitch.c
// Function: cmd_video_pitch_exec
int
cmd_video_pitch_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_video_pitch video_pitch_req;
	struct ps3av_reply reply;
	char *endptr;
	unsigned int head, pitch;
	int ret;

	head = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	pitch = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	ps3av_init_request(PS3AV_REQ(&video_pitch_req),
	    sizeof(video_pitch_req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_VIDEO_PITCH);

	video_pitch_req.head = head;
	video_pitch_req.pitch = pitch;

	ret = dev_write(&video_pitch_req, sizeof(video_pitch_req));
	if (ret != sizeof(video_pitch_req))
		return (CMD_EIO);

	ret = dev_read(&reply, sizeof(reply));
	if (ret != sizeof(reply))
		return (CMD_EIO);

	if (reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10d0
movq %rax, %r14
movq (%rbx), %rax
movl $0x2, %ebx
cmpb $0x0, (%rax)
jne 0x181b
movq 0x8(%r15), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
jne 0x181b
movabsq $0x1000005000c0205, %rcx # imm = 0x1000005000C0205
leaq 0x20(%rsp), %rdi
movq %rcx, (%rdi)
movl %r14d, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movl $0x10, %esi
callq 0x13e8
movl $0x3, %ebx
cmpl $0x10, %eax
jne 0x181b
leaq 0x14(%rsp), %rdi
movl $0xc, %esi
callq 0x1409
cmpl $0xc, %eax
jne 0x181b
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: intercambiar1
void intercambiar1(float *A,float *B)
{
  float tmp;
  tmp=*A;
  *A=*B;
  *B=tmp;
  mostrar1(*A,*B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movss (%rdi), %xmm0
movss (%rsi), %xmm1
movss %xmm1, (%rdi)
movss %xmm0, (%rsi)
leaq 0xe2c(%rip), %r15       # 0x2020
leaq 0xe36(%rip), %rsi       # 0x2031
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
leaq 0xe11(%rip), %r14       # 0x2025
movq %r14, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xe0f(%rip), %rsi       # 0x2034
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
movq %r14, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: main
int main(int argc,char *argv[])
{
  float x,y;
  x=1.4142;
  y=3.1416;
  printf("Version: ");
  VERSION(X,Y,Z);
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  printf("\n");
  printf("intercambiar:\n");
  intercambiar(x,y);/*paso de argumentos por valor*/
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  printf("\n");
  printf("intercambiar1:\n");
  intercambiar1(&x,&y);/*paso de argumentos por referencia*/
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x30(%rbp), %rax
movl $0x3fb50481, (%rax)     # imm = 0x3FB50481
leaq -0x2c(%rbp), %rax
movl $0x40490ff9, (%rax)     # imm = 0x40490FF9
leaq 0xdc4(%rip), %rdi       # 0x2037
xorl %eax, %eax
callq 0x1050
leaq 0xdc0(%rip), %rdi       # 0x2041
leaq 0x2db8(%rip), %rsi      # 0x4040
leaq 0x2db6(%rip), %rdx      # 0x4045
leaq 0x2db2(%rip), %rcx      # 0x4048
xorl %eax, %eax
callq 0x1050
leaq 0xdee(%rip), %rdi       # 0x2092
callq 0x1040
leaq 0xd70(%rip), %r15       # 0x2020
leaq 0xd93(%rip), %r14       # 0x204a
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
leaq 0xd5a(%rip), %r12       # 0x2025
movsd 0xd35(%rip), %xmm0      # 0x2008
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xd68(%rip), %r13       # 0x204c
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
movsd 0xd17(%rip), %xmm0      # 0x2010
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xd8f(%rip), %rbx       # 0x2099
movq %rbx, %rdi
callq 0x1040
movl $0xa, %edi
callq 0x1030
leaq 0xd52(%rip), %rdi       # 0x2075
callq 0x1040
movss 0xce8(%rip), %xmm0      # 0x2018
movss 0xce4(%rip), %xmm1      # 0x201c
callq 0x115c
leaq 0xd4e(%rip), %rdi       # 0x2092
callq 0x1040
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
movq %r12, %rdi
movsd 0xca7(%rip), %xmm0      # 0x2008
movb $0x1, %al
callq 0x1050
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
movq %r12, %rdi
movsd 0xc90(%rip), %xmm0      # 0x2010
movb $0x1, %al
callq 0x1050
movq %rbx, %rdi
callq 0x1040
movl $0xa, %edi
callq 0x1030
leaq 0xce3(%rip), %rdi       # 0x2083
callq 0x1040
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
leaq -0x2c(%rbp), %r14
movq %r14, %rsi
callq 0x11cd
leaq 0xcd3(%rip), %rdi       # 0x2092
callq 0x1040
movq %r15, %rdi
leaq 0xc7c(%rip), %rsi       # 0x204a
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xc8d(%rip), %rdi       # 0x2099
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/snowcrash/snowcrash.c
// Function: main
int main(int argc, char *argv[])
{
  int x, y, maxy, maxx;

  srand(time(NULL));

  initscr();
  atexit((void *)endwin);
  noecho();
  timeout(0);

  while (1) {
    if (getch() != ERR)
      return 0; /* Stop on any key press. */

    getmaxyx(stdscr, maxy, maxx);
    for (y = 0; y < maxy; y++) {
      for (x = 0; x < maxx; x++) {
        mvaddch(y, x, (rand() % 0x5E) + 0x21); /* 0x21 -> 0x7E */
      }
    }
    refresh();
    usleep(40000); /* ~24 frames per second. */
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
callq 0x1050
movq 0x2ddf(%rip), %rdi      # 0x3ff0
callq 0x12f0
callq 0x1040
movq 0x2db6(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
xorl %esi, %esi
callq 0x1080
movq (%r15), %rdi
callq 0x1030
cmpl $-0x1, %eax
jne 0x12de
movq (%r15), %rax
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1259
movswl 0x4(%rax), %r13d
incl %r13d
testq %rax, %rax
je 0x1266
movswl 0x6(%rax), %r12d
incl %r12d
testl %r13d, %r13d
jle 0x12c7
xorl %ebx, %ebx
testl %r12d, %r12d
jle 0x12c0
xorl %ebp, %ebp
movq (%r15), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x10a0
cmpl $-0x1, %eax
je 0x12b9
movq (%r15), %r14
callq 0x10d0
cltq
imulq $-0x51b3bea3, %rax, %rcx # imm = 0xAE4C415D
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x6, %ecx
addl %edx, %ecx
imull $0x5e, %ecx, %ecx
negl %ecx
leal (%rax,%rcx), %esi
addl $0x21, %esi
movq %r14, %rdi
callq 0x10c0
incl %ebp
cmpl %ebp, %r12d
jne 0x1274
incl %ebx
cmpl %r13d, %ebx
jne 0x126d
movq (%r15), %rdi
callq 0x1060
movl $0x9c40, %edi           # imm = 0x9C40
callq 0x10e0
jmp 0x122c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: closeClientRequest
static void closeClientRequest(int i)
{
  ssize_t r;
  char    buf[4];

  logDebug("closeClientRequest: read i=%d\n", i);
  r = read(stream[i].fd, buf, sizeof(buf));

  logDebug("close-on-eof %s r=%d i=%d fd=%d %s\n", streamTypeName[stream[i].type], (int) r, i, stream[i].fd, strerror(errno));
  closeStream(i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0x6bb5(%rip), %rdi      # 0x9c49
movl %ebx, %esi
xorl %eax, %eax
callq 0x7549
movslq %ebx, %rbx
imulq $0x8038, %rbx, %r15     # imm = 0x8038
leaq 0xb472(%rip), %r12      # 0xe520
movl (%r15,%r12), %edi
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x21b0
movq %rax, %r14
movl (%r15,%r12), %ebp
movl 0x4(%r15,%r12), %eax
leaq 0xb12c(%rip), %rcx      # 0xe200
movq (%rcx,%rax,8), %r15
callq 0x2050
movl (%rax), %edi
callq 0x2360
leaq 0x6b7d(%rip), %rdi      # 0x9c68
movq %r15, %rsi
movl %r14d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x7549
movl %ebx, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4062
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: acceptClient
void acceptClient(SOCKET s, StreamType ct)
{
  SOCKET             r;
  struct sockaddr_in clientAddr;
  socklen_t          clientAddrLen;

  for (;;)
  {
    clientAddrLen = sizeof(clientAddr);
    r             = accept(s, (struct sockaddr *) &clientAddr, &clientAddrLen);
    if (r == INVALID_SOCKET)
    {
      /* No socket ready, just ignore */
      return;
    }

    /* New client found, mark it as such */
    if (setFdUsed(r, ct) < 0)
    {
      /* Too many open clients, ignore */
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movl $0x10, 0x4(%rsp)
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22d0
cmpl $-0x1, %eax
je 0x3206
movl %eax, %edi
movl %ebx, %esi
callq 0x3211
testl %eax, %eax
jns 0x31df
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: parseUDPAddress
bool parseUDPAddress(char *target, char *port)
{
  int              r;
  struct addrinfo  hints;
  struct addrinfo *res, *res0;

  hints.ai_flags    = 0;
  hints.ai_family   = PF_INET;
  hints.ai_socktype = SOCK_DGRAM;
  hints.ai_protocol = IPPROTO_UDP;
  hints.ai_flags    = AI_NUMERICHOST;

  r = getaddrinfo(target, port, &hints, &res0);
  if (r)
  {
    return false;
  }
  for (res = res0; res; res = res->ai_next)
  {
    if (res->ai_addrlen == sizeof udpWildcardAddress)
    {
      memcpy(&udpWildcardAddress, res->ai_addr, sizeof udpWildcardAddress);
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movabsq $0x1100000002, %rax     # imm = 0x1100000002
leaq 0x10(%rsp), %rdx
movq %rax, 0x8(%rdx)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, (%rdx)
leaq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x2350
testl %eax, %eax
setne %cl
movq (%rbx), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x3474
cmpl $0x10, 0x10(%rax)
je 0x3478
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x3465
xorl %eax, %eax
jmp 0x3488
movq 0x18(%rax), %rax
movups (%rax), %xmm0
movups %xmm0, 0xaef6(%rip)     # 0xe37c
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: setHaveNMEA0183Client
static void setHaveNMEA0183Client(void)
{
  int i;

  haveNMEA0183Client = udp183;
  if (!haveNMEA0183Client)
  {
    for (i = 0; i <= socketIdxMax; i++)
    {
      if (stream[i].fd != INVALID_SOCKET
          && (stream[i].type == CLIENT_NMEA0183_STREAM || stream[i].type == SERVER_NMEA0183_DATAGRAM
              || stream[i].type == DATA_OUTPUT_NMEA0183_STREAM))
      {
        haveNMEA0183Client = true;
        return;
      }
    }
  }
}

// Assembly:
movb 0xa506(%rip), %al       # 0xe510
movb %al, 0xa368(%rip)       # 0xe378
testb %al, %al
jne 0x4059
movl 0xa356(%rip), %eax      # 0xe370
testl %eax, %eax
js 0x4059
imulq $0x8038, %rax, %rax     # imm = 0x8038
addq $0x8038, %rax           # imm = 0x8038
xorl %ecx, %ecx
leaq 0xa4ec(%rip), %rdx      # 0xe520
movl $0x41020, %esi          # imm = 0x41020
cmpl $-0x1, (%rcx,%rdx)
je 0x404d
movl 0x4(%rcx,%rdx), %edi
cmpl $0x12, %edi
ja 0x404d
btl %edi, %esi
jb 0x405a
addq $0x8038, %rcx           # imm = 0x8038
cmpq %rcx, %rax
jne 0x4039
retq
movb $0x1, 0xa317(%rip)      # 0xe378
retq
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: closeStream
static void closeStream(int i)
{
  int j;

  close(stream[i].fd);
  FD_CLR(stream[i].fd, &activeSet);
  FD_CLR(stream[i].fd, &readSet);
  FD_CLR(stream[i].fd, &writeSet);
  sbClean(&stream[i].writeBuffer);

  stream[i].fd = INVALID_SOCKET; /* Free for re-use */
  if (i == socketIdxMax)
  {
    socketIdxMax = 0;
    socketFdMax  = 0;
    for (j = i - 1; j >= 0; j--)
    {
      if (stream[j].fd != INVALID_SOCKET)
      {
        socketIdxMax = CB_MAX(socketIdxMax, j);
        socketFdMax  = CB_MAX(socketFdMax, stream[j].fd);
      }
    }
  }
  setHaveNMEA0183Client();
  logDebug("closeStream(%d) (%u..%u fdMax=%d)\n", i, socketIdxMin, socketIdxMax, socketFdMax);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %rax
imulq $0x8038, %rax, %r12     # imm = 0x8038
leaq 0xa4a3(%rip), %r14      # 0xe520
leaq (%r14,%r12), %r15
movl (%r12,%r14), %edi
callq 0x2190
movl (%r12,%r14), %ecx
movq $-0x2, %rax
rolq %cl, %rax
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rcx
leaq 0xa2e3(%rip), %rdx      # 0xe390
andq %rax, (%rdx,%rcx,8)
leaq 0xa358(%rip), %rdx      # 0xe410
andq %rax, (%rdx,%rcx,8)
leaq 0xa3cd(%rip), %rdx      # 0xe490
andq %rax, (%rdx,%rcx,8)
movq 0x8018(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x40e4
callq 0x2030
movq $0x0, 0x8018(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8020(%r15)
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
cmpl %ebx, 0xa274(%rip)      # 0xe370
jne 0x415c
xorl %eax, %eax
movl %eax, 0xa26a(%rip)      # 0xe370
movl %eax, 0xa268(%rip)      # 0xe374
testl %ebx, %ebx
jle 0x415c
movl %ebx, %ecx
imulq $0x8038, %rcx, %rdx     # imm = 0x8038
addq %r14, %rdx
addq $-0x8038, %rdx          # imm = 0xFFFF7FC8
xorl %esi, %esi
movl (%rdx), %edi
cmpl $-0x1, %edi
je 0x4148
leal -0x1(%rcx), %r8d
cmpl %r8d, %eax
cmovlel %r8d, %eax
movl %eax, 0xa233(%rip)      # 0xe370
cmpl %edi, %esi
cmovlel %edi, %esi
movl %esi, 0xa22c(%rip)      # 0xe374
decq %rcx
leaq 0x1(%rcx), %rdi
addq $-0x8038, %rdx          # imm = 0xFFFF7FC8
cmpq $0x1, %rdi
jg 0x4125
callq 0x4004
movl 0xa205(%rip), %edx      # 0xe36c
movl 0xa203(%rip), %ecx      # 0xe370
movl 0xa200(%rip), %r8d      # 0xe374
leaq 0x5800(%rip), %rdi      # 0x997b
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7549
// File: /workspace/github_c_makefile_star2_O1/canboat[P]canboat/n2kd/main.c
// Function: safeWriteBuffer
static void safeWriteBuffer(int idx, StringBuffer *sb)
{
  int r;

  if (stream[idx].writeBuffer.len > 0 && sb != &stream[idx].writeBuffer)
  {
    // Awww shit, last time we did not write everything, append the
    // new bits to the old unwritten data and try to write the buffered
    // data
    sbAppendData(&stream[idx].writeBuffer, sb->data, sb->len);
    sb = &stream[idx].writeBuffer;
  }

  // We are told the stream is ready to write, but it is in non-blocked
  // mode so it can write less than the buffer.

  r = write(stream[idx].fd, sb->data, sb->len);
  if (r < sb->len)
  {
    if (r <= 0)
    {
      if (errno != EAGAIN)
      {
        if (stream[idx].type == DATA_OUTPUT_COPY || stream[idx].type == DATA_OUTPUT_STREAM)
        {
          logAbort("Cannot write to stdout: %s\n", strerror(errno));
        }
        logError("Closing %s stream %d: %s\n", streamTypeName[stream[idx].type], stream[idx].fd, strerror(errno));
        closeStream(idx);
      }
    }
    else
    {
      if (sb == &stream[idx].writeBuffer)
      {
        // Remove the part of the buffer we did write
        sbDelete(sb, 0, (size_t) r);
      }
      else
      {
        // Store the remaining part in the per-fd writebuffer
        // and write it on the next attempt
        sbAppendData(&stream[idx].writeBuffer, sb->data + r, sb->len - r);
      }
    }
  }
  else
  {
    if (sb == &stream[idx].writeBuffer)
    {
      sbEmpty(sb);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movslq %edi, %rax
leaq 0xa37a(%rip), %rcx      # 0xe520
imulq $0x8038, %rax, %rax     # imm = 0x8038
leaq (%rcx,%rax), %r15
addq $0x8018, %r15           # imm = 0x8018
movq %rcx, %r12
addq %rax, %r12
cmpq $0x0, 0x8020(%rcx,%rax)
sete %al
cmpq %rsi, %r15
sete %cl
orb %al, %cl
jne 0x41e6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x78d2
movq %r15, %r14
movl (%r12), %edi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x20e0
movslq %eax, %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
jbe 0x4221
testl %eax, %eax
jle 0x423b
cmpq %r15, %r14
je 0x4250
addq (%r14), %rcx
movq %r15, %rdi
movq %rcx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x78d2
cmpq %r15, %r14
jne 0x4247
movq $0x0, 0x8(%r14)
movq (%r14), %rax
testq %rax, %rax
je 0x4247
movb $0x0, (%rax)
jmp 0x4247
callq 0x2050
movl (%rax), %edi
cmpl $0xb, %edi
jne 0x4265
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
xorl %esi, %esi
movq %rcx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x786e
movq %rax, %r14
movl 0x4(%r12), %eax
andl $-0x2, %eax
cmpl $0x10, %eax
jne 0x428b
callq 0x2360
leaq 0x5992(%rip), %rdi      # 0x9c13
movq %rax, %rsi
xorl %eax, %eax
callq 0x766f
movl (%r12), %ebp
movl 0x4(%r12), %eax
leaq 0x9f65(%rip), %rcx      # 0xe200
movq (%rcx,%rax,8), %r15
movl (%r14), %edi
callq 0x2360
leaq 0x5981(%rip), %rdi      # 0x9c2f
movq %r15, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x75dc
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4062