LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: function_args_shadow_function
static int _function_args_shadow_function(
		const struct _lair_token *new_token,
		const struct _lair_token **shadowed) {
	const struct _lair_token *cur = new_token->prev;
	while (cur != NULL) {
		if (cur->token_type != LR_FUNCTION_DEF &&
				cur->token_type != LR_FUNCTION_ARG) {
			break;
		}

		const int32_t cmp_result = strcmp(
				new_token->token_str, cur->token_str);
		if (cur->token_str != NULL && cmp_result == 0) {
			*shadowed = cur;
			return 1;
		}

		cur = cur->prev;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b81
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x4b39
movq -0x20(%rbp), %rax
cmpl $0x5, 0x8(%rax)
je 0x4b39
jmp 0x4b81
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1120
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4b73
cmpl $0x0, -0x24(%rbp)
jne 0x4b73
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4b88
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4b1c
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/qpfiffer[P]lair/src/parse.c
// Function: lair_atomize_token
struct _lair_type _lair_atomize_token(const struct _lair_token *token) {
	/* This is where we do parse-time type coersion into things that
	 * better represent the types we're eventually going to want out
	 * of whatever it is they are in.
	 */
	switch (token->token_type) {
		case LR_NUM: {
			struct _lair_type num = {
				.type = LR_NUM,
				.value = {
					.num = atoi(token->token_str)
				}
			};
			return num;
		}
		case LR_STRING: {
			struct _lair_type def = {
				.type = token->token_type,
				.value = {0}
			};
			if (token->token_str != NULL)
				def.value.str = _convert_str_token_to_str(token->token_str);
			return def;
		}
		default: {
			struct _lair_type def = {
				.type = token->token_type,
				.value = {0}
			};
			if (token->token_str != NULL) {
				def.value.str = calloc(1, strlen(token->token_str) + 1);
				memcpy(def.value.str, token->token_str, strlen(token->token_str));
			}
			return def;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0xa, %eax
je 0x4be2
jmp 0x4bbd
movl -0x1c(%rbp), %eax
subl $0xf, %eax
jne 0x4c0c
jmp 0x4bc7
movl $0xf, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0x8(%rbp)
jmp 0x4c76
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4c0a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4c90
movq %rax, -0x8(%rbp)
jmp 0x4c76
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4c74
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movq %rax, %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x1110
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1140
jmp 0x4c76
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: convert_str_token_to_str
static char *_convert_str_token_to_str(const char *token) {
	/* This function does stuff like convert escaped characters to their
	 * proper values, remove double quotes, etc.
	 */
	/* TODO: Escape stuff here. Like \r, \n, \t, etc. */
	const size_t string_len = strlen(token);
	const size_t new_string_len = string_len - strlen("\"\"");
	char *to_return = malloc(new_string_len + 1);
	to_return[new_string_len] = '\0';

	//memcpy(to_return, token + 1, new_string_len);
	int offset = 0;
	size_t i = 0;
	for (i = 0, offset = 1; i < new_string_len; i++, offset++) {
		if (token[offset] != '\\') {
			to_return[i] = token[offset];
		} else {
			switch (token[++offset]) {
				case 'n':
					to_return[i] = '\n';
					break;
				case 'r':
					to_return[i] = '\r';
					break;
				case 't':
					to_return[i] = '\t';
					break;
				default:
					to_return[i] = token[offset];
					break;
			}
		}
	}
	to_return[i] = '\0';
	return to_return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x1150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4db7
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x4d27
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4d9b
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rax
movl %eax, %edx
incl %edx
movl %edx, -0x24(%rbp)
movsbl 0x1(%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
subl $0x6e, %eax
je 0x4d59
jmp 0x4d45
movl -0x34(%rbp), %eax
subl $0x72, %eax
je 0x4d67
jmp 0x4d4f
movl -0x34(%rbp), %eax
subl $0x74, %eax
je 0x4d75
jmp 0x4d83
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0xa, (%rax,%rcx)
jmp 0x4d99
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0xd, (%rax,%rcx)
jmp 0x4d99
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x9, (%rax,%rcx)
jmp 0x4d99
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4d9b
jmp 0x4d9d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4cf0
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: lair_free_tokens
void _lair_free_tokens(struct _lair_token *tokens) {
	while (tokens != NULL) {
		struct _lair_token *to_free = (struct _lair_token *)tokens;
		tokens = tokens->next;
		_lair_free_token(to_free);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e02
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e10
jmp 0x4ddc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: lair_parse_from_tokens
struct _lair_ast *_lair_parse_from_tokens(
		struct _lair_runtime *r,
		struct _lair_token **tokens) {
	check(r, tokens != NULL, ERR_PARSE, "No tokens to parse.");
	struct _lair_ast *ast_root = calloc(1, sizeof(struct _lair_ast));
	struct _lair_ast *child_loc = ast_root->children;

	while ((*tokens) != NULL) {
		struct _lair_ast *to_append = _parse_from_token(tokens);

		struct _lair_token *unused = _pop_token(tokens);
		if (unused != NULL)
			_lair_free_token(unused);

		if (ast_root->children == NULL) {
			ast_root->children = to_append;
			child_loc = ast_root->children;
		} else {
			child_loc->sibling = to_append;
			child_loc = child_loc->sibling;
		}
	}

	/* The root node should never have any siblings. */
	check(r, ast_root->next == NULL, ERR_PARSE, "The tree got messed up somehow.");
	return ast_root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
xorl %edx, %edx
leaq 0x1955(%rip), %rcx      # 0x67bf
callq 0x1830
movl $0x1, %edi
movl $0x38, %esi
callq 0x1110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4f01
movq -0x10(%rbp), %rdi
callq 0x4f30
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4ec2
movq -0x30(%rbp), %rdi
callq 0x4e10
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4ee7
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4eff
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4e8e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %esi
xorl %edx, %edx
leaq 0x18b4(%rip), %rcx      # 0x67d3
callq 0x1830
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: pop_token
static inline struct _lair_token *_pop_token(struct _lair_token **tokens) {
	if (*tokens == NULL)
		return NULL;

	struct _lair_token *top = *tokens;
	*tokens = (*tokens)->next;

	return top;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x512c
movq $0x0, -0x8(%rbp)
jmp 0x5151
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/lair.c
// Function: lair_load_file
char *lair_load_file(const char *file_path, size_t *buf_size) {
	struct stat st = {0};
	if (stat(file_path, &st) == -1)
		return NULL;

	int fd = open(file_path, O_RDONLY);
	if (fd <= 0)
		return NULL;

	*buf_size = st.st_size;
	char *loaded = mmap(NULL, *buf_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (loaded == MAP_FAILED || loaded == NULL)
		return NULL;

	close(fd);

	return loaded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x10b0
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1130
cmpl $-0x1, %eax
jne 0x51f8
movq $0x0, -0x8(%rbp)
jmp 0x528f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1190
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jg 0x521e
movq $0x0, -0x8(%rbp)
jmp 0x528f
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0xac(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x1070
movq %rax, -0xb8(%rbp)
movq $-0x1, %rax
cmpq %rax, -0xb8(%rbp)
je 0x526f
cmpq $0x0, -0xb8(%rbp)
jne 0x5279
movq $0x0, -0x8(%rbp)
jmp 0x528f
movl -0xac(%rbp), %edi
callq 0x10e0
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/lair.c
// Function: lair_execute
int lair_execute(const char *program, const size_t len) {
	struct _lair_runtime *runtime = _lair_runtime_start();
	if (setjmp(runtime->exception_buffer)) {
		if (runtime->exception_msg) {
			print_error(runtime->exception_type, runtime->exception_msg);
		}
		goto error;
	}

	struct _lair_token *tokens = _lair_tokenize(runtime, program, len);
	if (tokens == NULL)
		goto error;

#ifdef DEBUG
	lair_print_tokens(tokens);
#endif
	const struct _lair_ast *ast = _lair_parse_from_tokens(runtime, &tokens);
	if (ast == NULL)
		return 1;

	_lair_eval(runtime, ast);
	_lair_free_tokens(tokens);
	_lair_runtime_end(runtime);
	return 0;

error:
	_lair_free_tokens(tokens);
	_lair_runtime_end(runtime);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x5160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x1100
cmpl $0x0, %eax
je 0x52eb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x52e9
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x18f0
jmp 0x5352
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5309
jmp 0x5352
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4e40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x532a
movl $0x1, -0x4(%rbp)
jmp 0x536b
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x30d0
movq -0x28(%rbp), %rdi
callq 0x4dd0
movq -0x20(%rbp), %rdi
callq 0x5190
movl $0x0, -0x4(%rbp)
jmp 0x536b
movq -0x28(%rbp), %rdi
callq 0x4dd0
movq -0x20(%rbp), %rdi
callq 0x5190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ibperfcli.c
// Function: ibperf_analyze
static bool
ibperf_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  const u64 nb = vctr_get(va, 0);
  const double mbps = ((double)nb) / (dt * (1024.0*1024.0));
  const bool done = damp_add_test(damp, mbps);
  const double havg = damp_average(damp);
  const char * const pat = " bytes %"PRIu64" mbps %.4lf havg %.4lf\n";
  sprintf(out, pat, nb, mbps, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
vmovsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb1f0
movq %rax, -0x28(%rbp)
vcvtusi2sdq -0x28(%rbp), %xmm0, %xmm0
vmovsd 0x1517f(%rip), %xmm1    # 0x1c008
vmulsd -0x10(%rbp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
vmovsd -0x30(%rbp), %xmm0
callq 0xad50
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaae0
vmovsd %xmm0, -0x40(%rbp)
leaq 0x15155(%rip), %rax     # 0x1c014
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
vmovsd -0x30(%rbp), %xmm0
vmovsd -0x40(%rbp), %xmm1
leaq 0x15138(%rip), %rsi     # 0x1c014
movb $0x2, %al
callq 0x62f0
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ibperfcli.c
// Function: ibperf_help_message
static void
ibperf_help_message(void)
{
  fprintf(stderr, "Usage: <stdout> <stderr> api <ib-port> <host> <port> <depth> <max-unit> {rgen ... {pass ... }}\n");
  fprintf(stderr, "rgen: not used. passes: pset/pdel/pget ignored. rgenopt should be 0.\n");
  maptest_passes_message();
  fprintf(stderr, "set MAP_TEST_PERF=y to enable perf recording\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1c09d(%rip), %rax     # 0x22fe8
movq (%rax), %rdi
leaq 0x150e1(%rip), %rsi     # 0x1c036
movb $0x0, %al
callq 0x65e0
movq 0x1c085(%rip), %rax     # 0x22fe8
movq (%rax), %rdi
leaq 0x15129(%rip), %rsi     # 0x1c096
movb $0x0, %al
callq 0x65e0
callq 0x17630
movq 0x1c068(%rip), %rax     # 0x22fe8
movq (%rax), %rdi
leaq 0x15152(%rip), %rsi     # 0x1c0dc
movb $0x0, %al
callq 0x65e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_port_create
struct ib_port *
ib_port_create(const u64 index)
{
  int num = 0;
  struct ibv_device ** const list = ibv_get_device_list(&num);
  u64 base = 0;
  for (int i = 0; i < num; i++) {
    struct ibv_context * const ctx = ibv_open_device(list[i]);
    if (ctx == NULL) {
      ibv_free_device_list(list);
      return NULL;
    }
    struct ibv_device_attr attr = {};
    const int q = ibv_query_device(ctx, &attr);
    debug_assert(q == 0);

    const u8 np = attr.phys_port_cnt;
    if ((base + np) > index) {
      struct ib_port * const port = (typeof(port))malloc(sizeof(*port));
      debug_assert(port);
      port->ctx = ctx;
      port->port_id = index - base + 1;
      port->pd = ibv_alloc_pd(ctx);
      debug_assert(port->pd);
      ibv_free_device_list(list);
      return port;
    }
    ibv_close_device(ctx);
    base += np;
  }
  ibv_free_device_list(list);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x6440
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a399
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6230
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1a280
movq -0x20(%rbp), %rdi
callq 0x60e0
movq $0x0, -0x8(%rbp)
jmp 0x1a3aa
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xe8, %edx
callq 0x6080
movq -0x38(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x62b0
movl %eax, -0x124(%rbp)
cmpl $0x0, -0x124(%rbp)
sete %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movb -0x3d(%rbp), %al
movb %al, -0x125(%rbp)
movq -0x28(%rbp), %rax
movzbl -0x125(%rbp), %ecx
addq %rcx, %rax
cmpq -0x10(%rbp), %rax
jbe 0x1a373
movl $0x18, %edi
callq 0x61b0
movq %rax, -0x130(%rbp)
cmpq $0x0, -0x130(%rbp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movq -0x38(%rbp), %rcx
movq -0x130(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
addq $0x1, %rax
movb %al, %cl
movq -0x130(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x65f0
movq %rax, %rcx
movq -0x130(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x130(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movq -0x20(%rbp), %rdi
callq 0x60e0
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a3aa
movq -0x38(%rbp), %rdi
callq 0x6390
movzbl -0x125(%rbp), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a242
movq -0x20(%rbp), %rdi
callq 0x60e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_sge_refill_off
void *
ib_sge_refill_off(struct ibv_sge * const sg, struct ibv_mr * const mr, const size_t offset, const size_t size)
{
  debug_assert((offset + size) <= mr->length);
  sg->addr = ((u64)mr->addr) + offset;
  sg->length = size;
  sg->lkey = mr->lkey;
  return (void *)sg->addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setbe %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_sge_refill_ptr
u64
ib_sge_refill_ptr(struct ibv_sge * const sg, struct ibv_mr * const mr, void * const ptr, const size_t size)
{
  debug_assert((((u64)ptr) + size - ((u64)mr->addr)) <= mr->length);
  debug_assert(ptr >= mr->addr);
  sg->addr = (u64)ptr;
  sg->length = size;
  sg->lkey = mr->lkey;
  return ptr - mr->addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setbe %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setae %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x77b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_export
bool
ib_socket_export(struct ib_socket * const s, struct ib_remote * const r)
{
  struct ibv_port_attr attr = {};
  if (ibv_query_port(s->port->ctx, s->port->port_id, &attr) != 0) {
    return false;
  }
  r->lid = attr.lid;
  r->qpn = s->qp->qp_num;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x4c(%rbp), %rdi
xorl %esi, %esi
movl $0x34, %edx
callq 0x6080
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq -0x4c(%rbp), %rdx
movzbl 0x8(%rax), %esi
callq 0x1a860
cmpl $0x0, %eax
je 0x1a829
movb $0x0, -0x1(%rbp)
jmp 0x1a849
movzwl -0x2a(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_connect
bool
ib_socket_connect(struct ib_socket * const s, struct ib_remote * const r)
{
  // RTR
  struct ibv_qp_attr qattr = {};
  qattr.qp_state = IBV_QPS_RTR;
  qattr.path_mtu = IBV_MTU_4096;
  qattr.dest_qp_num = r->qpn;
  qattr.rq_psn = IB1_PSN;

  qattr.ah_attr.is_global = 0;
  qattr.ah_attr.dlid = r->lid;
  qattr.ah_attr.sl = 0;
  qattr.ah_attr.src_path_bits = 0;
  qattr.ah_attr.port_num = s->port->port_id;

  // RC only
  qattr.max_dest_rd_atomic = 16;
  qattr.min_rnr_timer = 12;
  const int mask1 = IB1_SOCKET_QP_RTR_RC;
  const int r1 = ibv_modify_qp(s->qp, &qattr, mask1);
  if (r1 != 0) return false;

  // RTS
  qattr.qp_state = IBV_QPS_RTS;
  qattr.sq_psn = IB1_PSN;
  // RC only
  qattr.timeout = 14;
  qattr.retry_cnt = 7;
  qattr.rnr_retry = 7;
  qattr.max_rd_atomic = 16;
  qattr.max_dest_rd_atomic = 16;
  const int mask2 = IB1_SOCKET_QP_RTS_RC;
  const int r2 = ibv_modify_qp(s->qp, &qattr, mask2);
  if (r2 != 0) return false;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x6080
movl $0x2, -0xa8(%rbp)
movl $0x5, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x8c(%rbp)
movl $0x3e8, -0x94(%rbp)     # imm = 0x3E8
movb $0x0, -0x53(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movw %ax, -0x58(%rbp)
movb $0x0, -0x56(%rbp)
movb $0x0, -0x55(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb 0x8(%rax), %al
movb %al, -0x52(%rbp)
movb $0x10, -0x29(%rbp)
movb $0xc, -0x28(%rbp)
movl $0x129181, -0xac(%rbp)  # imm = 0x129181
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x129181, %edx         # imm = 0x129181
callq 0x62a0
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xb0(%rbp)
je 0x1a9e4
movb $0x0, -0x1(%rbp)
jmp 0x1aa48
movl $0x3, -0xa8(%rbp)
movl $0x3e8, -0x90(%rbp)     # imm = 0x3E8
movb $0xe, -0x26(%rbp)
movb $0x7, -0x25(%rbp)
movb $0x7, -0x24(%rbp)
movb $0x10, -0x2a(%rbp)
movb $0x10, -0x29(%rbp)
movl $0x12e01, -0xb4(%rbp)   # imm = 0x12E01
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x12e01, %edx          # imm = 0x12E01
callq 0x62a0
movl %eax, -0xb8(%rbp)
cmpl $0x0, -0xb8(%rbp)
je 0x1aa44
movb $0x0, -0x1(%rbp)
jmp 0x1aa48
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_connect_stream2
bool
ib_socket_connect_stream2(struct ib_socket * const s, struct stream2 * const s2)
{
  struct ib_remote local = {};
  if (ib_socket_export(s, &local) == false) {
    fprintf(stderr, "export failed\n");
    return false;
  }
  fwrite(&local, sizeof(local), 1, s2->w);
  fflush(s2->w);

  struct ib_remote remote = {};
  if (1 != fread(&remote, sizeof(remote), 1, s2->r)) {
    fprintf(stderr, "read remote failed\n");
    return false;
  }

  const bool rc = ib_socket_connect(s, &remote);
  if (rc == false) {
    fprintf(stderr, "connect failed\n");
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x6080
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1a7e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1aab8
movq 0x854a(%rip), %rax      # 0x22fe8
movq (%rax), %rdi
leaq 0x22c0(%rip), %rsi      # 0x1cd68
movb $0x0, %al
callq 0x65e0
movb $0x0, -0x1(%rbp)
jmp 0x1ab73
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x65b0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x66d0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x6080
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x6420
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x1ab34
movq 0x84cb(%rip), %rax      # 0x22fe8
movq (%rax), %rdi
leaq 0x2250(%rip), %rsi      # 0x1cd77
movb $0x0, %al
callq 0x65e0
movb $0x0, -0x1(%rbp)
jmp 0x1ab73
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a930
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1ab6b
movq 0x848e(%rip), %rax      # 0x22fe8
movq (%rax), %rdi
leaq 0x2227(%rip), %rsi      # 0x1cd8b
movb $0x0, %al
callq 0x65e0
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_post_send
bool
ib_socket_post_send(struct ib_socket * const s, struct ibv_sge * const sg, const bool signaled)
{
  if (s->nr_sending >= s->depth) return false;
  struct ibv_send_wr * const wr = &(s->swr);
  wr->wr_id = s->wid++;
  wr->sg_list = sg;
  wr->opcode = IBV_WR_SEND;
  wr->send_flags = signaled ? IBV_SEND_SIGNALED : 0;
  if (signaled) s->nr_sending++;
  struct ibv_send_wr * bad_wr = NULL;
  const int r = ibv_post_send(s->qp, wr, &bad_wr);
  return r == 0 ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jb 0x1abb8
movb $0x0, -0x1(%rbp)
jmp 0x1ac69
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0xd0(%rax)
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x2, 0x1c(%rax)
movb -0x19(%rbp), %dl
xorl %ecx, %ecx
movl $0x2, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
testb $0x1, -0x19(%rbp)
je 0x1ac2e
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd8(%rax)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1ac80
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_post_recv
bool
ib_socket_post_recv(struct ib_socket * const s, struct ibv_sge * const sg)
{
  if (s->nr_recving >= s->depth) return false;
  struct ibv_recv_wr * const wr = &(s->rwr);
  wr->wr_id = s->wid++;
  wr->sg_list = sg;
  struct ibv_recv_wr * bad_wr = NULL;
  const int r = ibv_post_recv(s->qp, wr, &bad_wr);
  s->nr_recving++;
  return r == 0 ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jb 0x1acf1
movb $0x0, -0x1(%rbp)
jmp 0x1ad7c
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0xd0(%rax)
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x1ad90
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movl -0x2c(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_flush_send
bool
ib_socket_flush_send(struct ib_socket * const s)
{
  while (s->nr_sending) {
    const int n = ibv_poll_cq(s->cqs, s->depth, s->wc);
    if (n < 0) {
      return false;
    }
    if (n == 0) continue;
    for (int i = 0; i < n; i++) {
      if (s->wc[i].status != IBV_WC_SUCCESS) {
        return false;
      }
    }
    s->nr_sending -= n;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x1ae80
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1ae90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1ae1f
movb $0x0, -0x1(%rbp)
jmp 0x1ae84
cmpl $0x0, -0x14(%rbp)
jne 0x1ae27
jmp 0x1addc
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1ae62
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x1ae55
movb $0x0, -0x1(%rbp)
jmp 0x1ae84
jmp 0x1ae57
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1ae2e
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xd8(%rax)
jmp 0x1addc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_flush_recv
bool
ib_socket_flush_recv(struct ib_socket * const s)
{
  while (s->nr_recving) {
    const int n = ibv_poll_cq(s->cqr, s->depth, s->wc);
    if (n < 0) {
      return false;
    }
    if (n == 0) continue;
    for (int i = 0; i < n; i++) {
      if (s->wc[i].status != IBV_WC_SUCCESS) {
        return false;
      }
    }
    s->nr_recving -= n;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x1af80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1ae90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1af1f
movb $0x0, -0x1(%rbp)
jmp 0x1af84
cmpl $0x0, -0x14(%rbp)
jne 0x1af27
jmp 0x1aedc
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1af62
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x1af55
movb $0x0, -0x1(%rbp)
jmp 0x1af84
jmp 0x1af57
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1af2e
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
jmp 0x1aedc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_poll_send
bool
ib_socket_poll_send(struct ib_socket * const s, u64 * const nr)
{
  const int n = ibv_poll_cq(s->cqs, s->depth, s->wc);
  if (n >= 0) {
    *nr = n;
    s->nr_sending -= n;
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1ae90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1aff5
movslq -0x1c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xd8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1aff9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_poll_recv
bool
ib_socket_poll_recv(struct ib_socket * const s, u64 * const nr)
{
  const int n = ibv_poll_cq(s->cqr, s->depth, s->wc);
  if (n >= 0) {
    *nr = n;
    s->nr_recving -= n;
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1ae90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1b075
movslq -0x1c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1b079
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ib1.c
// Function: ib_socket_destroy
void
ib_socket_destroy(struct ib_socket * const s)
{
  free(s->wc);
  ibv_destroy_qp(s->qp);
  ibv_destroy_cq(s->cqr);
  ibv_destroy_cq(s->cqs);
  free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6280
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6650
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6510
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6510
movq -0x8(%rbp), %rdi
callq 0x6280
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/test/test_tree.c
// Function: main
int main(void)
{
	MTREE_s *pTree = MTREE_create(NULL);

	for (int i = 0;i < DIM_OF(gArr);i++) {
		MTREE_addItem(pTree,gArr[i][0],gArr[i][1]);
	}

	printf("MTREE_forward:\n");
	MTREE_forward(pTree,forwardPrint);

	printf("MTREE_backward:\n");
	MTREE_backward(pTree,backwardPrint);

	MTREE_printByList(pTree);

	printf("MTREE_forward:\n");
	MTREE_forward(pTree,forwardPrint);

	printf("MTREE_backward:\n");
	MTREE_backward(pTree,backwardPrint);

	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x12d0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x1a, %rax
jae 0x123e
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x3e34(%rip), %rax      # 0x5050
movl (%rax,%rcx,8), %esi
movslq -0x14(%rbp), %rcx
leaq 0x3e26(%rip), %rax      # 0x5050
movl 0x4(%rax,%rcx,8), %edx
callq 0x1430
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1203
leaq 0x1dc8(%rip), %rdi      # 0x300d
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rdi
leaq -0xd7(%rip), %rsi       # 0x1180
callq 0x1880
leaq 0x1dba(%rip), %rdi      # 0x301d
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rdi
leaq -0xc5(%rip), %rsi       # 0x11b0
callq 0x1da0
movq -0x10(%rbp), %rdi
callq 0x1b60
leaq 0x1d83(%rip), %rdi      # 0x300d
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rdi
leaq -0x11c(%rip), %rsi      # 0x1180
callq 0x1880
leaq 0x1d75(%rip), %rdi      # 0x301d
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rdi
leaq -0x10a(%rip), %rsi      # 0x11b0
callq 0x1da0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_create
MTREE_s *MTREE_create(void *usr)
{
	MTREE_s *pTree = (MTREE_s *)malloc(sizeof(MTREE_s));
	CHECK_EXPR_RET(pTree == NULL,NULL);
	memset(pTree,0,sizeof(MTREE_s));
	
	pTree->root = NULL;
	pTree->pQAdd = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->pQForward = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->pQBackward = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->num = 0;
	pTree->rootInverse = (MTREE_ITEM_s *)malloc(sizeof(MTREE_ITEM_s));
	CHECK_EXPR_RET(pTree->rootInverse == NULL,NULL);
	pTree->usr = usr;
	
	INIT_LIST_HEAD(&pTree->head);
	
	return pTree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x90, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131f
leaq 0x1d36(%rip), %rdi      # 0x302e
leaq 0x1d45(%rip), %rsi      # 0x3044
leaq 0x1d4a(%rip), %rdx      # 0x3050
movl $0xa, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x141e
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x1040
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x8, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x8, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x8, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0xa8, %edi
callq 0x1070
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x13de
leaq 0x1c74(%rip), %rdi      # 0x302e
leaq 0x1c83(%rip), %rsi      # 0x3044
leaq 0x1c88(%rip), %rdx      # 0x3050
movl $0x13, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x141e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREEResetSyncPrev
int MTREEResetSyncPrev(MTREE_s *pTree)
{
	CHECK_EXPR_RET(pTree == NULL,-1);

	MTREE_ITEM_s *pItem = NULL;
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		pItem->syncPrev = pItem->nPrev;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1acd
leaq 0x1584(%rip), %rdi      # 0x302e
leaq 0x1593(%rip), %rsi      # 0x3044
leaq 0x1643(%rip), %rdx      # 0x30fb
movl $0x87, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b48
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x80(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
je 0x1b41
movq -0x18(%rbp), %rax
movl 0x90(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x94(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x98(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x1af3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_printByList
int MTREE_printByList(MTREE_s *pTree)
{
	CHECK_EXPR_RET(pTree == NULL,-1);

	MTREE_ITEM_s *pItem = NULL;
	pTree->nEnd = 0;

	printf("MTREE_printByList:\n");
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		printf("curr:%d\n",pItem->valCurr);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ba0
leaq 0x14b4(%rip), %rdi      # 0x302e
leaq 0x14c3(%rip), %rsi      # 0x3044
leaq 0x152e(%rip), %rdx      # 0x30b6
movl $0xbd, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c34
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
leaq 0x150e(%rip), %rdi      # 0x30c8
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x80(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
je 0x1c2d
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x13fe(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x98(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x1bdf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_getEndIds
int MTREE_getEndIds(MTREE_s *pTree,int *endId,int *n)
{
	CHECK_EXPR_RET(pTree == NULL,-1);
	CHECK_EXPR_RET(endId == NULL,-1);
	CHECK_EXPR_RET(n == NULL,-1);

	*n = 0;
	MTREE_ITEM_s *pItem = NULL;
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		if (pItem->nNext == 0) {
			endId[(*n)++] = pItem->valCurr;
		}
	}
	
	return 0;
}

// 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)
jne 0x1c88
leaq 0x13cc(%rip), %rdi      # 0x302e
leaq 0x13db(%rip), %rsi      # 0x3044
leaq 0x146c(%rip), %rdx      # 0x30dc
movl $0xcc, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d8a
cmpq $0x0, -0x18(%rbp)
jne 0x1cbc
leaq 0x1398(%rip), %rdi      # 0x302e
leaq 0x13a7(%rip), %rsi      # 0x3044
leaq 0x1438(%rip), %rdx      # 0x30dc
movl $0xcd, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d8a
cmpq $0x0, -0x20(%rbp)
jne 0x1cf0
leaq 0x1364(%rip), %rdi      # 0x302e
leaq 0x1373(%rip), %rsi      # 0x3044
leaq 0x1404(%rip), %rdx      # 0x30dc
movl $0xce, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d8a
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x80(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
je 0x1d83
movq -0x28(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x1d61
movq -0x28(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1d63
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x98(%rcx), %rax
movq %rax, -0x28(%rbp)
jmp 0x1d20
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/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREECalEndInfo
int MTREECalEndInfo(MTREE_s *pTree)
{
	CHECK_EXPR_RET(pTree == NULL,-1);

	MTREE_ITEM_s *pItem = NULL;
	pTree->nEnd = 0;
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		if (pItem->nNext == 0) {
			pTree->pEnd[pTree->nEnd++] = pItem;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2090
leaq 0xfc4(%rip), %rdi       # 0x302e
leaq 0xfd3(%rip), %rsi       # 0x3044
leaq 0x1096(%rip), %rdx      # 0x310e
movl $0x6d, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x212d
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x80(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
je 0x2126
movq -0x18(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x2104
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x68(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x68(%rsi)
movslq %ecx, %rcx
movq %rdx, 0x28(%rax,%rcx,8)
jmp 0x2106
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x98(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x20c1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREEResetSyncNext
int MTREEResetSyncNext(MTREE_s *pTree)
{
	CHECK_EXPR_RET(pTree == NULL,-1);

	MTREE_ITEM_s *pItem = NULL;
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		pItem->syncNext = pItem->nNext;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x217d
leaq 0xed4(%rip), %rdi       # 0x302e
leaq 0xee3(%rip), %rsi       # 0x3044
leaq 0xfb6(%rip), %rdx       # 0x311e
movl $0x7b, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21f2
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x80(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
je 0x21eb
movq -0x18(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movq %rax, %rdx
addq $0x98, %rdx
subq %rdx, %rax
addq 0x98(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x21a3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/Test/main.c
// Function: main
int main(void)
{
	srand((unsigned int)time(NULL));

	testCircularBuffer();
	testDynamicArray();
	testLinkedList();
	testQueue();
	testStack();

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
callq 0x39b0
callq 0x3e50
callq 0x41d0
callq 0x4640
callq 0x43f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq