LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x18e4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x18e2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x5430
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x5430
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1900
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x18d2
jmp 0x18e2
jmp 0x18d4
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x1879
jmp 0x18eb
movl $0x3, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x191d
jmp 0x193c
leaq 0x1d90a(%rip), %rdi     # 0x1f22e
leaq 0x1d912(%rip), %rsi     # 0x1f23d
movl $0x73, %edx
leaq 0x1d9eb(%rip), %rcx     # 0x1f322
callq 0x10d0
cmpq $0x0, -0x18(%rbp)
je 0x1945
jmp 0x1964
leaq 0x1da2d(%rip), %rdi     # 0x1f379
leaq 0x1d8ea(%rip), %rsi     # 0x1f23d
movl $0x74, %edx
leaq 0x1d9c3(%rip), %rcx     # 0x1f322
callq 0x10d0
cmpq $0x0, -0x20(%rbp)
je 0x196d
jmp 0x198c
leaq 0x1da12(%rip), %rdi     # 0x1f386
leaq 0x1d8c2(%rip), %rsi     # 0x1f23d
movl $0x75, %edx
leaq 0x1d99b(%rip), %rcx     # 0x1f322
callq 0x10d0
movq -0x18(%rbp), %rdi
leaq 0x1d9fd(%rip), %rsi     # 0x1f394
callq 0x1130
cmpl $0x0, %eax
jne 0x19ec
callq 0x1050
movl $0x0, (%rax)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x11d0
movw %ax, -0x22(%rbp)
callq 0x1050
cmpl $0x16, (%rax)
je 0x19d6
callq 0x1050
cmpl $0x22, (%rax)
jne 0x19df
movl $0x2, -0x4(%rbp)
jmp 0x19fc
movw -0x22(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
jmp 0x19f5
movl $0x1, -0x4(%rbp)
jmp 0x19fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a2c
jmp 0x1a4b
leaq 0x1d7fb(%rip), %rdi     # 0x1f22e
leaq 0x1d803(%rip), %rsi     # 0x1f23d
movl $0x3f, %edx
leaq 0x1d825(%rip), %rcx     # 0x1f26b
callq 0x10d0
cmpq $0x0, -0x10(%rbp)
je 0x1a54
jmp 0x1a73
leaq 0x1d85a(%rip), %rdi     # 0x1f2b5
leaq 0x1d7db(%rip), %rsi     # 0x1f23d
movl $0x40, %edx
leaq 0x1d7fd(%rip), %rcx     # 0x1f26b
callq 0x10d0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movl %eax, -0x18(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x2170
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
leaq -0x1f8(%rbp), %rdi
callq 0x2b00
leaq -0x1f8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x6090
movq -0x8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x1840
movl %eax, -0x14(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x2740
leaq -0x260(%rbp), %rdi
callq 0x5240
movl -0x14(%rbp), %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b0c
jmp 0x1b2b
leaq 0x1d71b(%rip), %rdi     # 0x1f22e
leaq 0x1d723(%rip), %rsi     # 0x1f23d
movl $0x54, %edx
leaq 0x1d7a3(%rip), %rcx     # 0x1f2c9
callq 0x10d0
cmpq $0x0, -0x10(%rbp)
je 0x1b34
jmp 0x1b53
leaq 0x1d7d6(%rip), %rdi     # 0x1f311
leaq 0x1d6fb(%rip), %rsi     # 0x1f23d
movl $0x55, %edx
leaq 0x1d77b(%rip), %rcx     # 0x1f2c9
callq 0x10d0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1f1d0(%rip), %rsi     # 0x20d35
callq 0x11b0
movq %rax, -0x268(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x2170
movq -0x268(%rbp), %rsi
leaq -0x1f8(%rbp), %rdi
callq 0x2ca0
leaq -0x1f8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x6090
movq -0x8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x1840
movl %eax, -0x14(%rbp)
movq -0x268(%rbp), %rdi
callq 0x1080
leaq -0x1f8(%rbp), %rdi
callq 0x2740
leaq -0x260(%rbp), %rdi
callq 0x5240
movl -0x14(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1070
callq 0x1050
movl %eax, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x16, 0x2ea0(%rip)     # 0x405c
callq 0x1060
cmpl $0x1, 0x10(%rsp)
jne 0x11df
leaq 0x2e8d(%rip), %rdi      # 0x405c
movl $0x2c, %esi
xorl %edx, %edx
callq 0x1080
movl %eax, 0xc(%rsp)
callq 0x1060
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x2e6a(%rip), %ecx      # 0x405c
leaq 0xe0b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x4810
movl $0x1, %edi
movl $0x6, %edx
movl %edx, %esi
callq 0x147e0
cmpq $0x0, %rax
je 0x47df
movq 0x7d830(%rip), %rax     # 0x81fd8
movq (%rax), %rax
movq %rax, (%rsp)
movl $0x1, %edi
movl $0x6, %edx
movl %edx, %esi
callq 0x147e0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x63836(%rip), %rsi     # 0x68004
movb $0x0, %al
callq 0x4450
movl $0x1, 0x14(%rsp)
jmp 0x47fb
callq 0x4a70
cmpl $0x0, %eax
je 0x47f3
movl $0x2, 0x14(%rsp)
jmp 0x47fb
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0xc(%rsp)
movl %esi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
cmpl $0x1, -0xc(%rsp)
jbe 0x14801
leaq 0x56507(%rip), %rax     # 0x6ad01
movq %rax, -0x8(%rsp)
jmp 0x14849
cmpl $0x1, -0xc(%rsp)
jae 0x14816
leaq 0x56527(%rip), %rax     # 0x6ad36
movq %rax, -0x8(%rsp)
jmp 0x14849
cmpl $0x6, -0x10(%rsp)
jbe 0x1482b
leaq 0x56547(%rip), %rax     # 0x6ad6b
movq %rax, -0x8(%rsp)
jmp 0x14849
cmpl $0x6, -0x14(%rsp)
jbe 0x14840
leaq 0x56567(%rip), %rax     # 0x6ada0
movq %rax, -0x8(%rsp)
jmp 0x14849
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11b7
movq 0x2e65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe60(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1242
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x123b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
cmpl $-0x1, %eax
jne 0x122e
movq 0x2e0a(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1060
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0xe00(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1242
jmp 0x1230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
imulq (%rax), %rsi
callq 0x11f0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x143b
callq 0x12e0
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1429
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq (%rcx), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
xorl %esi, %esi
callq 0x1080
jmp 0x142b
jmp 0x142b
jmp 0x142d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13d5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/ps3av.c
// Function: parse_opts
static int
parse_opts(int argc, char **argv, struct opts *opts)
{
	int c;

	while ((c = getopt_long(argc, argv, "hVvd:", long_opts, NULL)) != -1) {
		switch (c) {
		case 'h':
		case '?':
			opts->do_help = 1;
			return (0);
		break;
		case 'V':
			opts->do_version = 1;
			return (0);
		break;
		case 'v':
			opts->do_verbose++;
		break;
		case 'd':
			opts->device = optarg;
		break;
		default:
			fprintf(stderr, "invalid option specified: %c\n", c);
			return (-1);
		break;
		}
	}

	if (optind >= argc) {
		fprintf(stderr, "no command specified\n");
		return (-1);
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xd29(%rip), %rdx       # 0x209a
leaq 0x2d78(%rip), %rcx      # 0x40f0
xorl %eax, %eax
movl %eax, %r8d
callq 0x1050
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x143c
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x3f, %eax
je 0x13c3
jmp 0x139b
movl -0x20(%rbp), %eax
subl $0x56, %eax
je 0x13d9
jmp 0x13a5
movl -0x20(%rbp), %eax
subl $0x64, %eax
je 0x13ff
jmp 0x13af
movl -0x20(%rbp), %eax
subl $0x68, %eax
je 0x13c3
jmp 0x13b9
movl -0x20(%rbp), %eax
subl $0x76, %eax
je 0x13f0
jmp 0x1413
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1472
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1472
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x1437
movq 0x2bd2(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1437
movq 0x2bde(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0xc79(%rip), %rsi       # 0x20a0
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1472
jmp 0x1363
movq 0x2b8d(%rip), %rax      # 0x3fd0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x146b
movq 0x2ba7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc63(%rip), %rsi       # 0x20be
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1472
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x2c06(%rip)      # 0x4190
jge 0x1598
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1691
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
movl 0x2be4(%rip), %edi      # 0x4190
movq -0x1028(%rbp), %rsi
movl $0x4, %edx
callq 0x1070
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x15e4
callq 0x1030
cmpl $0xb, (%rax)
je 0x15e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1691
jmp 0x15f1
cmpl $0x0, -0x102c(%rbp)
jle 0x15ef
jmp 0x15f3
jmp 0x15f1
jmp 0x15a6
jmp 0x15f5
movl 0x2b95(%rip), %edi      # 0x4190
movq -0x1028(%rbp), %rsi
addq $0x4, %rsi
movq -0x1028(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %edx
callq 0x1070
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x163c
callq 0x1030
cmpl $0xb, (%rax)
je 0x163a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1691
jmp 0x1649
cmpl $0x0, -0x102c(%rbp)
jle 0x1647
jmp 0x164b
jmp 0x1649
jmp 0x15f5
movq -0x18(%rbp), %rax
movq -0x1028(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
addq $0x4, %rcx
cmpq %rcx, %rax
jbe 0x1676
movq -0x1028(%rbp), %rax
movzwl 0x2(%rax), %eax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10a0
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0xc, %edx
callq 0x1760
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x1520
movl %eax, -0x48(%rbp)
movslq -0x48(%rbp), %rax
cmpq $0x8, %rax
je 0x16ed
movl $0x3, -0x4(%rbp)
jmp 0x1748
leaq -0x44(%rbp), %rdi
movl $0x1c, %esi
callq 0x1570
movl %eax, -0x48(%rbp)
movslq -0x48(%rbp), %rax
cmpq $0x1c, %rax
je 0x1711
movl $0x3, -0x4(%rbp)
jmp 0x1748
cmpl $0x0, -0x3c(%rbp)
je 0x1720
movl $0x3, -0x4(%rbp)
jmp 0x1748
leaq -0x44(%rbp), %rdi
addq $0x10, %rdi
movl -0x38(%rbp), %eax
movl %eax, %edx
movq 0x2894(%rip), %rax      # 0x3fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x10f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x1860
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x1520
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
cmpq $0x8, %rax
je 0x17ed
movl $0x3, -0x4(%rbp)
jmp 0x184c
leaq -0x3c(%rbp), %rdi
movl $0x14, %esi
callq 0x1570
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
cmpq $0x14, %rax
je 0x1811
movl $0x3, -0x4(%rbp)
jmp 0x184c
cmpl $0x0, -0x34(%rbp)
je 0x1820
movl $0x3, -0x4(%rbp)
jmp 0x184c
movq 0x27a1(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movzwl -0x30(%rbp), %edx
movzwl -0x2e(%rbp), %ecx
movzwl -0x2c(%rbp), %r8d
leaq 0x8c8(%rip), %rsi       # 0x2106
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1b23
movl $0x2, -0x4(%rbp)
jmp 0x1bcd
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1b4e
movl $0x2, -0x4(%rbp)
jmp 0x1bcd
leaq -0x2c(%rbp), %rdi
movl $0x8, %esi
movl $0x10002, %edx          # imm = 0x10002
callq 0x1be0
movl -0x44(%rbp), %eax
movw %ax, -0x24(%rbp)
movl -0x48(%rbp), %eax
movw %ax, -0x22(%rbp)
leaq -0x2c(%rbp), %rdi
movl $0xc, %esi
callq 0x1520
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq $0xc, %rax
je 0x1b93
movl $0x3, -0x4(%rbp)
jmp 0x1bcd
leaq -0x38(%rbp), %rdi
movl $0xc, %esi
callq 0x1570
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq $0xc, %rax
je 0x1bb7
movl $0x3, -0x4(%rbp)
jmp 0x1bcd
cmpl $0x0, -0x30(%rbp)
je 0x1bc6
movl $0x3, -0x4(%rbp)
jmp 0x1bcd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1c63
movl $0x2, -0x4(%rbp)
jmp 0x1d0b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1c8e
movl $0x2, -0x4(%rbp)
jmp 0x1d0b
leaq -0x30(%rbp), %rdi
movl $0xc, %esi
movl $0x1000005, %edx        # imm = 0x1000005
callq 0x1d20
movl -0x4c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x1520
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpq $0x10, %rax
je 0x1cd1
movl $0x3, -0x4(%rbp)
jmp 0x1d0b
leaq -0x3c(%rbp), %rdi
movl $0xc, %esi
callq 0x1570
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpq $0xc, %rax
je 0x1cf5
movl $0x3, -0x4(%rbp)
jmp 0x1d0b
cmpl $0x0, -0x34(%rbp)
je 0x1d04
movl $0x3, -0x4(%rbp)
jmp 0x1d0b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: intercambiar
void intercambiar(float A,float B)
{
  float tmp;
  tmp=A;
  A=B;
  B=tmp;
  mostrar1(A,B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
leaq 0xe95(%rip), %rdi       # 0x200c
leaq 0xea0(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1030
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe7c(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
leaq 0xe69(%rip), %rdi       # 0x200c
leaq 0xe77(%rip), %rsi       # 0x2021
movb $0x0, %al
callq 0x1030
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe50(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
leaq 0xdfb(%rip), %rdi       # 0x200c
leaq 0xe05(%rip), %rsi       # 0x201d
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xddf(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
leaq 0xdcc(%rip), %rdi       # 0x200c
leaq 0xdd9(%rip), %rsi       # 0x2020
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xdb0(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0xd7a(%rip), %xmm0      # 0x2008
movss %xmm0, -0x14(%rbp)
movss 0xd69(%rip), %xmm0      # 0x2004
movss %xmm0, -0x18(%rbp)
leaq 0xd7c(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1030
leaq 0xd78(%rip), %rdi       # 0x202d
leaq 0x2d74(%rip), %rsi      # 0x4030
leaq 0x2d72(%rip), %rdx      # 0x4035
leaq 0x2d6e(%rip), %rcx      # 0x4038
movb $0x0, %al
callq 0x1030
leaq 0xd5e(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xd26(%rip), %rdi       # 0x200c
leaq 0xd51(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xd07(%rip), %rdi       # 0x200c
leaq 0xd34(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xd1e(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
leaq 0xd42(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
leaq 0xd36(%rip), %rdi       # 0x2076
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
callq 0x1140
leaq 0xcd9(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xca1(%rip), %rdi       # 0x200c
leaq 0xccc(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xc82(%rip), %rdi       # 0x200c
leaq 0xcaf(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xc99(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
leaq 0xcbd(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
leaq 0xcc0(%rip), %rdi       # 0x2085
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11d0
leaq 0xc56(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xc1e(%rip), %rdi       # 0x200c
leaq 0xc49(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xbff(%rip), %rdi       # 0x200c
leaq 0xc2c(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xc16(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
callq 0x1050
movq 0x2dce(%rip), %rdi      # 0x3ff0
callq 0x1360
callq 0x1040
movq 0x2da5(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1080
movq 0x2d94(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1030
cmpl $-0x1, %eax
je 0x1259
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
xorl %eax, %eax
movq 0x2d76(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x127d
movq 0x2d6a(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1287
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x1287
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
movq 0x2d42(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x12b1
movq 0x2d36(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12bb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x12bb
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x133c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x132f
movq 0x2cf2(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x10a0
cmpl $-0x1, %eax
jne 0x12fb
jmp 0x1324
movq 0x2cd6(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x10d0
movq -0x30(%rbp), %rdi
movl $0x5e, %ecx
cltd
idivl %ecx
movl %edx, %esi
addl $0x21, %esi
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12d7
jmp 0x1331
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12c8
movq 0x2c95(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1060
movl $0x9c40, %edi           # imm = 0x9C40
callq 0x10e0
jmp 0x123d
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/ok2.c
// Function: main
int main(int argc, char *argv[]) {
  char fmt[] = "%s\n";
  if (argc > 1) {
    (void)printf(fmt, argv[1]);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xea8(%rip), %eax       # 0x2004
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1178
leaq -0x14(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hts_endian.c
// Function: to_hex
static char * to_hex(uint8_t *buf, int len) {
    static char str[64];
    int i, o;

    for (i = 0, o = 0; i < len; i++, o += 3) {
        snprintf(str + o, sizeof(str) - o, "%02x ", buf[i]);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x156d
movslq -0x14(%rbp), %rax
leaq 0x3e80(%rip), %rdi      # 0x53b0
addq %rax, %rdi
movslq -0x14(%rbp), %rax
movl $0x40, %esi
subq %rax, %rsi
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x1bfb(%rip), %rdx      # 0x314d
movb $0x0, %al
callq 0x1050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x151d
leaq 0x3e3c(%rip), %rax      # 0x53b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hts_endian.c
// Function: main
int main(int argc, char **argv) {
    int verbose = 0;
    int errors = 0;

    if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1;

    errors += t16_bit(verbose);
    errors += t32_bit(verbose);
    errors += t64_bit(verbose);
    errors += t_float(verbose);
    errors += t_double(verbose);
    if (errors) {
        fprintf(stderr, "%d errors\n", errors);
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1a0a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1746(%rip), %rsi      # 0x313f
callq 0x1030
cmpl $0x0, %eax
jne 0x1a0a
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1a90
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x20d0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x26d0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x1160
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x15e0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1a7a
movq 0x3583(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x16d8(%rip), %rsi      # 0x3142
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x1a81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0xa260(%rip), %rdi      # 0xcc25
movb $0x0, %al
callq 0x9ae0
movslq -0x4(%rbp), %rcx
leaq 0xebc9(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
movl (%rax), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x21c0
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xeba0(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0xe7fa(%rip), %rax      # 0x11210
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xeb6a(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x2370
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq %rax, %r9
leaq 0xa1db(%rip), %rdi      # 0xcc44
movb $0x0, %al
callq 0x9ae0
movl -0x4(%rbp), %edi
callq 0x3a30
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x10, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x22f0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x2c30
jmp 0x2c44
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2c50
cmpl $0x0, %eax
jge 0x2c42
jmp 0x2c44
jmp 0x2c0e
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x2, -0x4c(%rbp)
movl $0x2, -0x48(%rbp)
movl $0x11, -0x44(%rbp)
movl $0x4, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2360
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x30b7
movb $0x0, -0x1(%rbp)
jmp 0x310a
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x3106
movq -0x58(%rbp), %rax
movl 0x10(%rax), %eax
cmpq $0x10, %rax
jne 0x30f6
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq %rcx, 0xe317(%rip)      # 0x113fc
movq 0x8(%rax), %rax
movq %rax, 0xe314(%rip)      # 0x11404
movb $0x1, -0x1(%rbp)
jmp 0x310a
jmp 0x30f8
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x30bf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/n2kd/main.c
// Function: startTcpServers
static void startTcpServers(void)
{
  tcpServer(port, SERVER_JSON);
  logInfo("TCP JSON server listening on port %d\n", port);
  tcpServer(port + 1, SERVER_JSON_STREAM);
  logInfo("TCP JSON stream server listening on port %d\n", port + 1);
  if (udp183)
  {
    tcpServer(port + 2, SERVER_NMEA0183_DATAGRAM);
    logInfo("UDP NMEA0183 datagram server sending on port %d\n", port + 2);
  }
  else
  {
    tcpServer(port + 2, SERVER_NMEA0183_STREAM);
    logInfo("TCP NMEA0183 server listening on port %d\n", port + 2);
  }

  tcpServer(port + 3, SERVER_INPUT_STREAM);
  logInfo("TCP input stream server listening on port %d\n", port + 3);

  tcpServer(port + 4, SERVER_AIS);
  logInfo("TCP AIS server listening on port %d\n", port + 4);

  tcpServer(port + 5, SERVER_STATUS);
  logInfo("TCP status server listening on port %d\n", port + 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x9, %esi
movzwl 0xda00(%rip), %edi      # 0x11200
callq 0x4c90
movzwl 0xd9f4(%rip), %esi      # 0x11200
leaq 0x94e8(%rip), %rdi      # 0xccfb
movb $0x0, %al
callq 0x9990
movzwl 0xd9df(%rip), %eax      # 0x11200
addl $0x1, %eax
movl $0xa, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd9c8(%rip), %esi      # 0x11200
addl $0x1, %esi
leaq 0x94df(%rip), %rdi      # 0xcd21
movb $0x0, %al
callq 0x9990
testb $0x1, 0xdd40(%rip)      # 0x11590
je 0x3883
movzwl 0xd9a7(%rip), %eax      # 0x11200
addl $0x2, %eax
movl $0xc, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd990(%rip), %esi      # 0x11200
addl $0x2, %esi
leaq 0x94d4(%rip), %rdi      # 0xcd4e
movb $0x0, %al
callq 0x9990
jmp 0x38b2
movzwl 0xd976(%rip), %eax      # 0x11200
addl $0x2, %eax
movl $0xb, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd95f(%rip), %esi      # 0x11200
addl $0x2, %esi
leaq 0x94d4(%rip), %rdi      # 0xcd7f
movb $0x0, %al
callq 0x9990
movzwl 0xd947(%rip), %eax      # 0x11200
addl $0x3, %eax
movl $0x8, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd930(%rip), %esi      # 0x11200
addl $0x3, %esi
leaq 0x94cf(%rip), %rdi      # 0xcda9
movb $0x0, %al
callq 0x9990
movzwl 0xd918(%rip), %eax      # 0x11200
addl $0x4, %eax
movl $0x7, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd901(%rip), %esi      # 0x11200
addl $0x4, %esi
leaq 0x94ce(%rip), %rdi      # 0xcdd7
movb $0x0, %al
callq 0x9990
movzwl 0xd8e9(%rip), %eax      # 0x11200
addl $0x5, %eax
movl $0xd, %esi
movzwl %ax, %edi
callq 0x4c90
movzwl 0xd8d2(%rip), %esi      # 0x11200
addl $0x5, %esi
leaq 0x94c4(%rip), %rdi      # 0xcdfc
movb $0x0, %al
callq 0x9990
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb 0xdc16(%rip), %al       # 0x11590
andb $0x1, %al
movb %al, 0xda76(%rip)       # 0x113f8
testb $0x1, 0xda6f(%rip)      # 0x113f8
jne 0x3a2b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xda51(%rip), %eax      # 0x113f0
jg 0x3a29
movslq -0x4(%rbp), %rcx
leaq 0xdbf0(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x3a19
movslq -0x4(%rbp), %rcx
leaq 0xdbd6(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
cmpl $0x5, 0x4(%rax)
je 0x3a10
movslq -0x4(%rbp), %rcx
leaq 0xdbbb(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
cmpl $0xc, 0x4(%rax)
je 0x3a10
movslq -0x4(%rbp), %rcx
leaq 0xdba0(%rip), %rax      # 0x115a0
imulq $0x8038, %rcx, %rcx     # imm = 0x8038
addq %rcx, %rax
cmpl $0x12, 0x4(%rax)
jne 0x3a19
movb $0x1, 0xd9e1(%rip)      # 0x113f8
jmp 0x3a2b
jmp 0x3a1b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3996
jmp 0x3a2b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/n2kd/main.c
// Function: requestAddressClaimAndProductInfo
static void requestAddressClaimAndProductInfo(int64_t now)
{
  if (now < lastRequestForProdInfo + UINT64_C(1000) * CLAIM_REQUEST_TIMEOUT)
  {
    return;
  }
  lastRequestForProdInfo = now;

  if (stream[stdoutfd].type == DATA_OUTPUT_COPY || stream[stdoutfd].type == DATA_OUTPUT_STREAM)
  {
    char         strTmp[DATE_LENGTH];
    StringBuffer msg = sbNew;

    sbAppendFormat(&msg, "%s,6,59904,0,255,3,14,f0,01\n", fmtNow(strTmp));
    sbAppendFormat(&msg, "%s,6,59904,0,255,3,00,ee,00\n", fmtNow(strTmp));
    safeWriteBuffer(stdoutfd, &msg);
    sbClean(&msg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x201acd9(%rip), %rcx   # 0x201f5f0
addq $0xea60, %rcx           # imm = 0xEA60
cmpq %rcx, %rax
jae 0x4928
jmp 0x49d9
movq -0x8(%rbp), %rax
movq %rax, 0x201acbd(%rip)   # 0x201f5f0
cmpl $0x10, 0x14ca2(%rip)    # 0x195dc
je 0x4949
cmpl $0x11, 0x14c99(%rip)    # 0x195dc
jne 0x49d9
leaq 0x20ae348(%rip), %rax   # 0x20b2c98
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9970
movq %rax, %rdx
leaq -0x68(%rbp), %rdi
leaq 0x8237(%rip), %rsi      # 0xcbb5
movb $0x0, %al
callq 0xa2b0
leaq -0x50(%rbp), %rdi
callq 0x9970
movq %rax, %rdx
leaq -0x68(%rbp), %rdi
leaq 0x8236(%rip), %rsi      # 0xcbd2
movb $0x0, %al
callq 0xa2b0
movl $0x1, %edi
leaq -0x68(%rbp), %rsi
callq 0x49e0
cmpq $0x0, -0x68(%rbp)
je 0x49c9
movq -0x68(%rbp), %rdi
callq 0x2030
movq $0x0, -0x68(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nop