LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/pickle/pickle_data.c
// Function: pickle_data__init
static int
pickle_data__init(PickleData* data, KeysStore store, size_t total_size, size_t max_array_size) {

	pickle_data__init_default(data);

	ASSERT(total_size > 0);
	ASSERT(max_array_size > PICKLE_TRIENODE_SIZE * 1024);

	data->bytes_list = F(PyList_New)(0);
	if (UNLIKELY(data->bytes_list == NULL)) {
		return false;
	}

	if (store == STORE_ANY) {
		data->values = F(PyList_New)(0);
		if (UNLIKELY(data->values == NULL)) {
			Py_DECREF(data->bytes_list);
			return false;
		}
	}

	if (total_size <= max_array_size) {
		data->size = total_size + PICKLE_CHUNK_COUNTER_SIZE;
		data->chunked = false;
	} else {
		// TODO: more heuristic here: what if total_size > 100MB? what if > 1GB, > 10GB?
		data->size = max_array_size;
		data->chunked = true;
	}

	return pickle_data__add_next_buffer(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb060
cmpq $0x0, -0x20(%rbp)
ja 0xa983
movq 0x76ba(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x16c8(%rip), %rsi      # 0xc010
leaq 0x4493(%rip), %rdx      # 0xede2
leaq 0x44a5(%rip), %rcx      # 0xedfb
movl $0x63, %r8d
leaq 0x44aa(%rip), %r9       # 0xee0d
movb $0x0, %al
callq 0x31b0
movq 0x7687(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0xa985
jmp 0xa987
cmpq $0x6000, -0x28(%rbp)    # imm = 0x6000
ja 0xa9dd
movq 0x7660(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x166e(%rip), %rsi      # 0xc010
leaq 0x4439(%rip), %rdx      # 0xede2
leaq 0x444b(%rip), %rcx      # 0xedfb
movl $0x64, %r8d
leaq 0x445f(%rip), %r9       # 0xee1c
movb $0x0, %al
callq 0x31b0
movq 0x762d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0xa9df
xorl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xaa16
movl $0x0, -0x4(%rbp)
jmp 0xaaa9
cmpl $0x1e, -0x14(%rbp)
jne 0xaa60
xorl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xaa5e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3a90
movl $0x0, -0x4(%rbp)
jmp 0xaaa9
jmp 0xaa60
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xaa84
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0xaa98
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xb120
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton_pickle.c
// Function: pickle_dump_undo_replace
static int
pickle_dump_undo_replace(TrieNode* node, const int depth, void* extra) {
#define state ((DumpState*)extra)
    NodeID* repl = (NodeID*)(node->fail);
    node->fail = repl->fail;
    memory_free(repl);

    return 1;
#undef state
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x34b0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/pickle/pickle_data.c
// Function: pickle_data__init_default
static void
pickle_data__init_default(PickleData* data) {
	ASSERT(data != NULL);

	data->bytes_list	= NULL;
	data->chunked		= false;
	data->size			= 0;
	data->data			= NULL;
	data->count			= NULL;
	data->top			= 0;
	data->values		= 0;
	data->error			= false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb0bf
movq 0x6f7e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xf8c(%rip), %rsi       # 0xc010
leaq 0x3d57(%rip), %rdx      # 0xede2
leaq 0x3db7(%rip), %rcx      # 0xee49
movl $0x7, %r8d
leaq 0x3dc4(%rip), %r9       # 0xee63
movb $0x0, %al
callq 0x31b0
movq 0x6f4b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0xb0c1
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/pickle/pickle_data.c
// Function: pickle_data__add_next_buffer
static bool
pickle_data__add_next_buffer(PickleData* data) {

	PyObject* bytes;
	void* raw;

	ASSERT(data != NULL);

	bytes = F(PyBytes_FromStringAndSize)(NULL, data->size);
	if (UNLIKELY(bytes == NULL)) {
		return false;
	}

	if (UNLIKELY(F(PyList_Append)(data->bytes_list, bytes) < 0)) {
		Py_DECREF(bytes);
		return false;
	}

	raw = PyBytes_AS_STRING(bytes);

	data->count 	= (Py_ssize_t*)raw;
	(*data->count)	= 0;

	data->data  	= (uint8_t*)raw;
	data->top   	= PICKLE_CHUNK_COUNTER_SIZE;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb17f
movq 0x6ebe(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xecc(%rip), %rsi       # 0xc010
leaq 0x3c97(%rip), %rdx      # 0xede2
leaq 0x3d1e(%rip), %rcx      # 0xee70
movl $0x23, %r8d
leaq 0x3d04(%rip), %r9       # 0xee63
movb $0x0, %al
callq 0x31b0
movq 0x6e8b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0xb181
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x30c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb1b4
movb $0x0, -0x1(%rbp)
jmp 0xb261
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x31a0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb1e6
movq -0x18(%rbp), %rdi
callq 0x3a90
movb $0x0, -0x1(%rbp)
jmp 0xb261
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x4450
cmpl $0x0, %eax
je 0xb1ff
jmp 0xb21e
leaq 0x1431(%rip), %rdi      # 0xc637
leaq 0x3bd5(%rip), %rsi      # 0xede2
movl $0x2f, %edx
leaq 0x3c74(%rip), %rcx      # 0xee8d
callq 0x3130
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x8, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/randombytes.c
// Function: randombytes
void randombytes(unsigned char *x,unsigned long long xlen)
{
  int i;

  if (fd == -1) {
    for (;;) {
      fd = open("/dev/urandom",O_RDONLY);
      if (fd != -1) break;
      sleep(1);
    }
  }

  while (xlen > 0) {
    if (xlen < 1048576) i = xlen; else i = 1048576;

    i = read(fd,x,i);
    if (i < 1) {
      sleep(1);
      continue;
    }

    x += i;
    xlen -= i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $-0x1, 0x7e59(%rip)     # 0x90b0
jne 0x128a
jmp 0x125b
leaq 0x4da2(%rip), %rdi      # 0x6004
xorl %esi, %esi
movb $0x0, %al
callq 0x10d0
movl %eax, 0x7e3f(%rip)      # 0x90b0
cmpl $-0x1, 0x7e38(%rip)     # 0x90b0
je 0x127c
jmp 0x1288
movl $0x1, %edi
callq 0x1130
jmp 0x125b
jmp 0x128a
jmp 0x128c
cmpq $0x0, -0x10(%rbp)
jbe 0x12f7
cmpq $0x100000, -0x10(%rbp)  # imm = 0x100000
jae 0x12a6
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x12ad
movl $0x100000, -0x14(%rbp)  # imm = 0x100000
movl 0x7dfd(%rip), %edi      # 0x90b0
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x12d5
movl $0x1, %edi
callq 0x1130
jmp 0x128c
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x128c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: error
void error(int code, char message[]) {
    fprintf(stderr, "Error: ");
    fputs(message, stderr);
    fprintf(stderr, "\n");
    exit(code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7ce2(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4cf1(%rip), %rsi      # 0x6011
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
movq 0x7cc6(%rip), %rax      # 0x8ff8
movq (%rax), %rsi
callq 0x1050
movq 0x7cb7(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4cce(%rip), %rsi      # 0x6019
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x1110
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: errorf
void errorf(int code, char message[], char arg[]) {
    fprintf(stderr, "Error: ");
    fprintf(stderr, message, arg);
    fprintf(stderr, "\n");
    exit(code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x7c7e(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4c8d(%rip), %rsi      # 0x6011
movb $0x0, %al
callq 0x1080
movq 0x7c66(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1080
movq 0x7c4d(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4c64(%rip), %rsi      # 0x6019
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x1110
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: bytes_to_hex
char * bytes_to_hex(unsigned char bytes[], int size) {
    char *hex = malloc((size * 2) + 1);
    if (hex == NULL) error(1, "Malloc failed!");
    for (int i = 0; i < size; i++) {
        sprintf(hex + (i * 2), "%02x", bytes[i]);
    }
    return hex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x140b
movl $0x1, %edi
leaq 0x4c15(%rip), %rsi      # 0x601b
callq 0x1300
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x144d
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x4bef(%rip), %rsi      # 0x602a
movb $0x0, %al
callq 0x1100
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1412
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: create_file
FILE * create_file(char filename[]) {
    // http://stackoverflow.com/a/230581
    int fd = open(filename, O_CREAT | O_WRONLY | O_EXCL, S_IRUSR | S_IWUSR);
    if (fd < 0) errorf(1, "Could not write to %s", filename);
    // http://stackoverflow.com/a/1941472
    return fdopen(fd, "wb");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x10d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x149f
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x4b95(%rip), %rsi      # 0x602f
callq 0x1360
movl -0xc(%rbp), %edi
leaq 0x4b9c(%rip), %rsi      # 0x6045
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: read_key
void read_key(char filename[], unsigned char key[], int key_size) {
    FILE *f = fopen(filename, "rb");
    if (fread(key, 1, key_size, f) != key_size)
        errorf(1, "Could not read the key from <%s>", filename);
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b2a(%rip), %rsi      # 0x6048
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1030
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x155b
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x4af5(%rip), %rsi      # 0x604b
callq 0x1360
movq -0x20(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tools.c
// Function: read_file
Content read_file(char filename[]) {
    FILE *f = fopen(filename, "rb");
    Content c;
    if (f == 0) errorf(1, "Could not read <%s>", filename);
    fseek(f, 0, SEEK_END);
    long size = ftell(f);
    if (size < 0) errorf(1, "Could not read <%s>", filename);
    c.size = (size_t)size;
    fseek(f, 0, SEEK_SET);
    c.bytes = malloc(c.size);
    if (c.bytes == NULL) error(1, "Malloc failed!");
    fread(c.bytes, c.size, 1, f);
    fclose(f);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4ac1(%rip), %rsi      # 0x6048
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15ac
movq -0x18(%rbp), %rdx
movl $0x1, %edi
leaq 0x4ac5(%rip), %rsi      # 0x606c
callq 0x1360
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x15e7
movq -0x18(%rbp), %rdx
movl $0x1, %edi
leaq 0x4a8a(%rip), %rsi      # 0x606c
callq 0x1360
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1623
movl $0x1, %edi
leaq 0x49fd(%rip), %rsi      # 0x601b
callq 0x1300
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: add1305
sv add1305(u32 *h,const u32 *c)
{
  u32 j,u = 0;
  FOR(j,17) {
    u += h[j] + c[j];
    h[j] = u & 255;
    u >>= 8;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x11, -0x18(%rbp)
jae 0x25f4
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
andq $0xff, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x259c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_secretbox_xsalsa20poly1305_tweet
int crypto_secretbox(u8 *c,const u8 *m,u64 d,const u8 *n,const u8 *k)
{
  int i;
  if (d < 32) return -1;
  crypto_stream_xor(c,m,d,n,k);
  crypto_onetimeauth(c + 16,c + 32,d - 32,c);
  FOR(i,16) c[i] = 0;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x20, -0x20(%rbp)
jae 0x266c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26d1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1ff0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
subq $0x20, %rdx
movq -0x10(%rbp), %rcx
callq 0x2050
movl $0x0, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jge 0x26ca
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x26ad
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_secretbox_xsalsa20poly1305_tweet_open
int crypto_secretbox_open(u8 *m,const u8 *c,u64 d,const u8 *n,const u8 *k)
{
  int i;
  u8 x[32];
  if (d < 32) return -1;
  crypto_stream(x,32,n,k);
  if (crypto_onetimeauth_verify(c + 16,c + 32,d - 32,x) != 0) return -1;
  crypto_stream_xor(m,c,d,n,k);
  FOR(i,32) m[i] = 0;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x20, -0x20(%rbp)
jae 0x270f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2798
leaq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x20, %esi
callq 0x1fa0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
subq $0x20, %rdx
leaq -0x60(%rbp), %rcx
callq 0x2600
cmpl $0x0, %eax
je 0x2754
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2798
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1ff0
movl $0x0, -0x34(%rbp)
cmpl $0x20, -0x34(%rbp)
jge 0x2791
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2774
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/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: sel25519
sv sel25519(gf p,gf q,int b)
{
  i64 t,i,c=~(b-1);
  FOR(i,16) {
    t= c&(p[i]^q[i]);
    p[i]^=t;
    q[i]^=t;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
xorl $-0x1, %eax
cltq
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x10, -0x28(%rbp)
jge 0x2d76
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rsi
xorq (%rdx,%rsi,8), %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2d16
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: M
sv M(gf o,const gf a,const gf b)
{
  i64 i,j,t[31];
  FOR(i,31) t[i]=0;
  FOR(i,16) FOR(j,16) t[i+j]+=a[i]*b[j];
  FOR(i,15) t[i]+=38*t[i+16];
  FOR(i,16) o[i]=t[i];
  car25519(o);
  car25519(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x1f, -0x20(%rbp)
jge 0x2e94
movq -0x20(%rbp), %rax
movq $0x0, -0x120(%rbp,%rax,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e6f
movq $0x0, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jge 0x2f01
movq $0x0, -0x28(%rbp)
cmpq $0x10, -0x28(%rbp)
jge 0x2ef1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
imulq (%rax,%rdx,8), %rcx
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
addq -0x120(%rbp,%rax,8), %rcx
movq %rcx, -0x120(%rbp,%rax,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2eab
jmp 0x2ef3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e9c
movq $0x0, -0x20(%rbp)
cmpq $0xf, -0x20(%rbp)
jge 0x2f3f
movq -0x20(%rbp), %rax
imulq $0x26, -0xa0(%rbp,%rax,8), %rcx
movq -0x20(%rbp), %rax
addq -0x120(%rbp,%rax,8), %rcx
movq %rcx, -0x120(%rbp,%rax,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f09
movq $0x0, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jge 0x2f74
movq -0x20(%rbp), %rax
movq -0x120(%rbp,%rax,8), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f47
movq -0x8(%rbp), %rdi
callq 0x4d50
movq -0x8(%rbp), %rdi
callq 0x4d50
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: inv25519
sv inv25519(gf o,const gf i)
{
  gf c;
  int a;
  FOR(a,16) c[a]=i[a];
  for(a=253;a>=0;a--) {
    S(c,c);
    if(a!=2&&a!=4) M(c,c,i);
  }
  FOR(a,16) o[a]=c[a];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x2fe5
movq -0x10(%rbp), %rax
movslq -0x94(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x94(%rbp), %rax
movq %rcx, -0x90(%rbp,%rax,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x2fad
movl $0xfd, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jl 0x3047
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2e20
cmpl $0x2, -0x94(%rbp)
je 0x3034
cmpl $0x4, -0x94(%rbp)
je 0x3034
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e50
jmp 0x3036
movl -0x94(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x2fef
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x3089
movslq -0x94(%rbp), %rax
movq -0x90(%rbp,%rax,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x94(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x3051
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack25519
sv pack25519(u8 *o,const gf n)
{
  int i,j,b;
  gf m,t;
  FOR(i,16) t[i]=n[i];
  car25519(t);
  car25519(t);
  car25519(t);
  FOR(j,2) {
    m[0]=t[0]-0xffed;
    for(i=1;i<15;i++) {
      m[i]=t[i]-0xffff-((m[i-1]>>16)&1);
      m[i-1]&=0xffff;
    }
    m[15]=t[15]-0x7fff-((m[14]>>16)&1);
    b=(m[15]>>16)&1;
    m[14]&=0xffff;
    sel25519(t,m,1-b);
  }
  FOR(i,16) {
    o[2*i]=t[i]&0xff;
    o[2*i+1]=t[i]>>8;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x30e3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x14(%rbp), %rax
movq %rcx, -0x120(%rbp,%rax,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30ba
leaq -0x120(%rbp), %rdi
callq 0x4d50
leaq -0x120(%rbp), %rdi
callq 0x4d50
leaq -0x120(%rbp), %rdi
callq 0x4d50
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x3203
movq -0x120(%rbp), %rax
subq $0xffed, %rax           # imm = 0xFFED
movq %rax, -0xa0(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0xf, -0x14(%rbp)
jge 0x319d
movslq -0x14(%rbp), %rax
movq -0x120(%rbp,%rax,8), %rcx
subq $0xffff, %rcx           # imm = 0xFFFF
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq -0xa0(%rbp,%rax,8), %rax
sarq $0x10, %rax
andq $0x1, %rax
subq %rax, %rcx
movslq -0x14(%rbp), %rax
movq %rcx, -0xa0(%rbp,%rax,8)
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq -0xa0(%rbp,%rax,8), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq %rcx, -0xa0(%rbp,%rax,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3133
movq -0xa8(%rbp), %rax
subq $0x7fff, %rax           # imm = 0x7FFF
movq -0x30(%rbp), %rcx
sarq $0x10, %rcx
andq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
sarq $0x10, %rax
andq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x30(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x1, %edx
subl -0x1c(%rbp), %edx
callq 0x2cf0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x310e
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x3262
movslq -0x14(%rbp), %rax
movq -0x120(%rbp,%rax,8), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movslq -0x14(%rbp), %rax
movq -0x120(%rbp,%rax,8), %rax
sarq $0x8, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x320a
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_hash_sha512_tweet
int crypto_hash(u8 *out,const u8 *m,u64 n)
{
  u8 h[64],x[256];
  u64 i,b = n;

  FOR(i,64) h[i] = iv[i];

  crypto_hashblocks(h,m,n);
  m += n;
  n &= 127;
  m -= n;

  FOR(i,256) x[i] = 0;
  FOR(i,n) x[i] = m[i];
  x[n] = 128;

  n = 256-128*(n<112);
  x[n-9] = b >> 61;
  ts64(x+n-8,b<<3);
  crypto_hashblocks(h,x,n);

  FOR(i,64) out[i] = h[i];

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x170(%rbp)
movq $0x0, -0x168(%rbp)
cmpq $0x40, -0x168(%rbp)
jae 0x3b67
movq -0x168(%rbp), %rcx
leaq 0x286b(%rip), %rax      # 0x63b0
movb (%rax,%rcx), %cl
movq -0x168(%rbp), %rax
movb %cl, -0x60(%rbp,%rax)
movq -0x168(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x168(%rbp)
jmp 0x3b2d
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3450
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
andq $0x7f, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x168(%rbp)
cmpq $0x100, -0x168(%rbp) # imm = 0x100
jae 0x3bdf
movq -0x168(%rbp), %rax
movb $0x0, -0x160(%rbp,%rax)
movq -0x168(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x168(%rbp)
jmp 0x3baf
movq $0x0, -0x168(%rbp)
movq -0x168(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3c27
movq -0x10(%rbp), %rax
movq -0x168(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x168(%rbp), %rax
movb %cl, -0x160(%rbp,%rax)
movq -0x168(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x168(%rbp)
jmp 0x3bea
movq -0x18(%rbp), %rax
movb $-0x80, -0x160(%rbp,%rax)
cmpq $0x70, -0x18(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x7, %ecx
movl $0x100, %eax            # imm = 0x100
subl %ecx, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x170(%rbp), %rax
shrq $0x3d, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
subq $0x9, %rax
movb %cl, -0x160(%rbp,%rax)
leaq -0x160(%rbp), %rdi
addq -0x18(%rbp), %rdi
addq $-0x8, %rdi
movq -0x170(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3ab0
leaq -0x60(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3450
movq $0x0, -0x168(%rbp)
cmpq $0x40, -0x168(%rbp)
jae 0x3ce1
movq -0x168(%rbp), %rax
movb -0x60(%rbp,%rax), %dl
movq -0x8(%rbp), %rax
movq -0x168(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x168(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x168(%rbp)
jmp 0x3caa
xorl %eax, %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_sign_ed25519_tweet_keypair
int crypto_sign_keypair(u8 *pk, u8 *sk)
{
  u8 d[64];
  gf p[4];
  int i;

  randombytes(sk, 32);
  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  scalarbase(p,d);
  pack(pk,p);

  FOR(i,32) sk[32 + i] = pk[i];
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x1240
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x3b00
movzbl -0x50(%rbp), %eax
andl $0xf8, %eax
movb %al, -0x50(%rbp)
movzbl -0x31(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
orl $0x40, %eax
movb %al, -0x31(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3dc0
movq -0x8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3e60
movl $0x0, -0x254(%rbp)
cmpl $0x20, -0x254(%rbp)
jge 0x3da8
movq -0x8(%rbp), %rax
movslq -0x254(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x254(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x3d6d
xorl %eax, %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: scalarbase
sv scalarbase(gf p[4],const u8 *s)
{
  gf q[4];
  set25519(q[0],X);
  set25519(q[1],Y);
  set25519(q[2],gf1);
  M(q[3],X,Y);
  scalarmult(p,q,s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
leaq 0x26af(%rip), %rsi      # 0x6490
callq 0x4e50
leaq -0x210(%rbp), %rdi
addq $0x80, %rdi
leaq 0x2715(%rip), %rsi      # 0x6510
callq 0x4e50
leaq -0x210(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x277b(%rip), %rsi      # 0x6590
callq 0x4e50
leaq -0x210(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x2661(%rip), %rsi      # 0x6490
leaq 0x26da(%rip), %rdx      # 0x6510
callq 0x2e50
movq -0x8(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4950
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack
sv pack(u8 *r,gf p[4])
{
  gf tx, ty, zi;
  inv25519(zi, p[2]); 
  M(tx, p[0], zi);
  M(ty, p[1], zi);
  pack25519(r, ty);
  r[31] ^= par25519(tx) << 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x190(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
callq 0x2f90
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x2e50
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
leaq -0x190(%rbp), %rdx
callq 0x2e50
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x30a0
leaq -0x90(%rbp), %rdi
callq 0x4e90
movzbl %al, %edx
shll $0x7, %edx
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x1f(%rax)
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_sign_ed25519_tweet_open
int crypto_sign_open(u8 *m,u64 *mlen,const u8 *sm,u64 n,const u8 *pk)
{
  int i;
  u8 t[32],h[64];
  gf p[4],q[4];

  *mlen = -1;
  if (n < 64) return -1;

  if (unpackneg(q,pk)) return -1;

  FOR(i,n) m[i] = sm[i];
  FOR(i,32) m[i+32] = pk[i];
  crypto_hash(h,m,n);
  reduce(h);
  scalarmult(p,q,h);

  scalarbase(q,sm + 32);
  add(p,q);
  pack(t,p);

  n -= 64;
  if (crypto_verify_32(sm, t)) {
    FOR(i,n) m[i] = 0;
    return -1;
  }

  FOR(i,n) m[i] = sm[i + 64];
  *mlen = n;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp            # imm = 0x4A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
cmpq $0x40, -0x28(%rbp)
jae 0x450d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x469c
leaq -0x4a0(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x46b0
cmpl $0x0, %eax
je 0x452e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x469c
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x4560
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4535
movl $0x0, -0x34(%rbp)
cmpl $0x20, -0x34(%rbp)
jge 0x4593
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4567
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3b00
leaq -0xa0(%rbp), %rdi
callq 0x41f0
leaq -0x2a0(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4950
leaq -0x4a0(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x3dc0
leaq -0x2a0(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x4a50
leaq -0x60(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x3e60
movq -0x28(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1700
cmpl $0x0, %eax
je 0x4653
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x464a
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4629
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x469c
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x468a
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x40, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x465a
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4a0, %rsp            # imm = 0x4A0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: scalarmult
sv scalarmult(gf p[4],gf q[4],const u8 *s)
{
  int i;
  set25519(p[0],gf0);
  set25519(p[1],gf1);
  set25519(p[2],gf1);
  set25519(p[3],gf0);
  for (i = 255;i >= 0;--i) {
    u8 b = (s[i/8]>>(i&7))&1;
    cswap(p,q,b);
    add(q,p);
    add(p,p);
    cswap(p,q,b);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1ea1(%rip), %rsi      # 0x6810
callq 0x4e50
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
leaq 0x1c0a(%rip), %rsi      # 0x6590
callq 0x4e50
movq -0x8(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x1bf3(%rip), %rsi      # 0x6590
callq 0x4e50
movq -0x8(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x1e5c(%rip), %rsi      # 0x6810
callq 0x4e50
movl $0xff, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x4a3b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x1c(%rbp), %ecx
andl $0x7, %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzbl -0x1d(%rbp), %edx
callq 0x5000
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4a50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4a50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzbl -0x1d(%rbp), %edx
callq 0x5000
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x49c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: add
sv add(gf p[4],gf q[4])
{
  gf a,b,c,d,t,e,f,g,h;
  
  Z(a, p[1], p[0]);
  Z(t, q[1], q[0]);
  M(a, a, t);
  A(b, p[0], p[1]);
  A(t, q[0], q[1]);
  M(b, b, t);
  M(c, p[3], q[3]);
  M(c, c, D2);
  M(d, p[2], q[2]);
  A(d, d, d);
  Z(e, b, a);
  Z(f, d, c);
  A(g, d, c);
  A(h, b, a);

  M(p[0], e, f);
  M(p[1], h, g);
  M(p[2], g, f);
  M(p[3], e, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp            # imm = 0x490
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x80, %rsi
movq -0x8(%rbp), %rdx
callq 0x2dd0
leaq -0x290(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
movq -0x10(%rbp), %rdx
callq 0x2dd0
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x290(%rbp), %rdx
callq 0x2e50
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x80, %rdx
callq 0x2d80
leaq -0x290(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
callq 0x2d80
leaq -0x110(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq -0x290(%rbp), %rdx
callq 0x2e50
leaq -0x190(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x180, %rsi            # imm = 0x180
movq -0x10(%rbp), %rdx
addq $0x180, %rdx            # imm = 0x180
callq 0x2e50
leaq -0x190(%rbp), %rdi
leaq -0x190(%rbp), %rsi
leaq 0x1d56(%rip), %rdx      # 0x6890
callq 0x2e50
leaq -0x210(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movq -0x10(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
callq 0x2e50
leaq -0x210(%rbp), %rdi
leaq -0x210(%rbp), %rsi
leaq -0x210(%rbp), %rdx
callq 0x2d80
leaq -0x310(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x2dd0
leaq -0x390(%rbp), %rdi
leaq -0x210(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x2dd0
leaq -0x410(%rbp), %rdi
leaq -0x210(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x2d80
leaq -0x490(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x2d80
movq -0x8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
leaq -0x390(%rbp), %rdx
callq 0x2e50
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
leaq -0x490(%rbp), %rsi
leaq -0x410(%rbp), %rdx
callq 0x2e50
movq -0x8(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x410(%rbp), %rsi
leaq -0x390(%rbp), %rdx
callq 0x2e50
movq -0x8(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq -0x310(%rbp), %rsi
leaq -0x490(%rbp), %rdx
callq 0x2e50
addq $0x490, %rsp            # imm = 0x490
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: ld32
static u32 ld32(const u8 *x)
{
  u32 u = x[3];
  u = (u<<8)|x[2];
  u = (u<<8)|x[1];
  return (u<<8)|x[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: car25519
sv car25519(gf o)
{
  int i;
  i64 c;
  FOR(i,16) {
    o[i]+=(1LL<<16);
    c=o[i]>>16;
    o[(i+1)*(i<15)]+=c-1+37*(c-1)*(i==15);
    o[i]-=c<<16;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x4e10
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x10000, %rdx          # imm = 0x10000
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
sarq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movq -0x18(%rbp), %rax
subq $0x1, %rax
imulq $0x25, %rax, %rax
cmpl $0xf, -0xc(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl $0xf, -0xc(%rbp)
setl %sil
andb $0x1, %sil
movzbl %sil, %esi
imull %esi, %ecx
movslq %ecx, %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rsi
shlq $0x10, %rsi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
subq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d5f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pow2523
sv pow2523(gf o,const gf i)
{
  gf c;
  int a;
  FOR(a,16) c[a]=i[a];
  for(a=250;a>=0;a--) {
    S(c,c);
    if(a!=1) M(c,c,i);
  }
  FOR(a,16) o[a]=c[a];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x4f15
movq -0x10(%rbp), %rax
movslq -0x94(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x94(%rbp), %rax
movq %rcx, -0x90(%rbp,%rax,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x4edd
movl $0xfa, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jl 0x4f6e
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2e20
cmpl $0x1, -0x94(%rbp)
je 0x4f5b
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e50
jmp 0x4f5d
movl -0x94(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x4f1f
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x4fb0
movslq -0x94(%rbp), %rax
movq -0x90(%rbp,%rax,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x94(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x4f78
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl-sigpair.c
// Function: output_key
void output_key(char filename[], unsigned char key[], int key_size) {
    // http://stackoverflow.com/a/8004250
    if (strcmp(filename, "-") != 0) {
        FILE *out = create_file(filename);
        fwrite(key, key_size, 1, out);
        fclose(out);
    } else {
        fwrite(bytes_to_hex(key, key_size), key_size * 2, 1, stdout);
        fputs("\n", stdout);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1892(%rip), %rsi      # 0x6910
callq 0x1070
cmpl $0x0, %eax
je 0x50b6
movq -0x8(%rbp), %rdi
callq 0x1460
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x1040
jmp 0x50f7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13d0
movq %rax, %rdi
movl -0x14(%rbp), %eax
shll %eax
movslq %eax, %rsi
movq 0x3f04(%rip), %rax      # 0x8fd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x1120
movq 0x3ef0(%rip), %rax      # 0x8fd8
movq (%rax), %rsi
leaq 0xf27(%rip), %rdi       # 0x6019
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl-sigpair.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 3) error(2, "Expected 2 filenames as arguments");

    unsigned char public_key[crypto_sign_PUBLICKEYBYTES];
    unsigned char secret_key[crypto_sign_SECRETKEYBYTES];
    crypto_sign_keypair(public_key, secret_key);

    if (file_exists(argv[1])) errorf(1, "File <%s> exists", argv[1]);
    if (file_exists(argv[2])) errorf(1, "File <%s> exists", argv[2]);

    output_key(argv[1], public_key, crypto_sign_PUBLICKEYBYTES);
    output_key(argv[2], secret_key, crypto_sign_SECRETKEYBYTES);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x512d
movl $0x2, %edi
leaq 0x17ea(%rip), %rsi      # 0x6912
callq 0x1300
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3cf0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14c0
cmpl $0x0, %eax
je 0x5165
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %edi
leaq 0x17d4(%rip), %rsi      # 0x6934
callq 0x1360
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x14c0
cmpl $0x0, %eax
je 0x5190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %edi
leaq 0x17a9(%rip), %rsi      # 0x6934
callq 0x1360
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x5060
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
callq 0x5060
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/bloques.c
// Function: bmount
int bmount (const char *camino) { 
	fichero = open(camino, O_RDWR|O_CREAT, 0666); 
	if(fichero < 0) printf("Error en la apertura del dispostivo\n");
	mutex = initSem();
	return fichero;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x42, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1140
movl %eax, 0x6e31(%rip)      # 0x80d8
cmpl $0x0, 0x6e2a(%rip)      # 0x80d8
jge 0x12be
leaq 0x4d4d(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x1090
movb $0x0, %al
callq 0x5da0
movq %rax, 0x6e14(%rip)      # 0x80e0
movl 0x6e06(%rip), %eax      # 0x80d8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: tamMB
int tamMB (unsigned int bloques) { 
	if((bloques/8)%tamBloque == 0) {
		return (bloques/8)/tamBloque;
	} else {
		return ((bloques/8)/tamBloque)+1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x3, %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl $0x0, %eax
jne 0x1445
movl -0x8(%rbp), %eax
shrl $0x3, %eax
shrl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x1454
movl -0x8(%rbp), %eax
shrl $0x3, %eax
shrl $0xa, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: tamAI
int tamAI (unsigned int inodos) { 
	if((inodos*tamInodo)%tamBloque == 0) {
		return (inodos*tamInodo)/tamBloque;
	} else {
		return ((inodos*tamInodo)/tamBloque)+1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
shll $0x7, %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl $0x0, %eax
jne 0x1485
movl -0x8(%rbp), %eax
shll $0x7, %eax
shrl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x1494
movl -0x8(%rbp), %eax
shll $0x7, %eax
shrl $0xa, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: initSB
int initSB (unsigned int bloques, unsigned int inodos) { 
	struct superbloque sb; //Definimos la zona de memoria (variable de tipo superbloque)
	sb.posPrimerBloqueMB = posSB+1;
	sb.posUltimoBloqueMB = sb.posPrimerBloqueMB+tamMB(bloques)-1;
	sb.posPrimerBloqueAI = sb.posUltimoBloqueMB+1;
	sb.posUltimoBloqueAI = sb.posPrimerBloqueAI+tamAI(inodos)-1;
	sb.posPrimerBloqueDatos = sb.posUltimoBloqueAI+1;
	sb.posUltimoBloqueDatos = bloques-1;
	sb.posInodoRaiz = 0;
	sb.posPrimerInodoLibre = 0;
	sb.cantBloquesLibres = bloques;
	sb.cantInodosLibres = inodos;
	sb.totBloques = bloques;
	sb.totInodos = inodos;
	
	if(bwrite(posSB,&sb) < 0) return -1; //Error BWRITE	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x40c(%rbp)
movl -0x40c(%rbp), %eax
movl %eax, -0x414(%rbp)
movl -0x8(%rbp), %edi
callq 0x1420
movl %eax, %ecx
movl -0x414(%rbp), %eax
addl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x408(%rbp)
movl -0x408(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x404(%rbp)
movl -0x404(%rbp), %eax
movl %eax, -0x410(%rbp)
movl -0xc(%rbp), %edi
callq 0x1460
movl %eax, %ecx
movl -0x410(%rbp), %eax
addl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x400(%rbp)
movl -0x400(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3fc(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3f8(%rbp)
movl $0x0, -0x3f4(%rbp)
movl $0x0, -0x3f0(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x3ec(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x3e8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x3e4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x3e0(%rbp)
xorl %edi, %edi
leaq -0x40c(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x1587
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x158e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)