// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/bspwm.c
// Function: main
int main(int argc, char *argv[])
{
	fd_set descriptors;
	char socket_path[MAXLEN];
	char state_path[MAXLEN] = {0};
	int run_level = 0;
	config_path[0] = '\0';
	int sock_fd = -1, cli_fd, dpy_fd, max_fd, n;
	struct sockaddr_un sock_address;
	char msg[BUFSIZ] = {0};
	xcb_generic_event_t *event;
	char *end;
	int opt;

	while ((opt = getopt(argc, argv, "hvc:s:o:")) != -1) {
		switch (opt) {
			case 'h':
				printf(WM_NAME " [-h|-v|-c CONFIG_PATH]\n");
				exit(EXIT_SUCCESS);
				break;
			case 'v':
				printf("%s\n", VERSION);
				exit(EXIT_SUCCESS);
				break;
			case 'c':
				snprintf(config_path, sizeof(config_path), "%s", optarg);
				break;
			case 's':
				run_level |= 1;
				snprintf(state_path, sizeof(state_path), "%s", optarg);
				break;
			case 'o':
				run_level |= 2;
				sock_fd = strtol(optarg, &end, 0);
				if (*end != '\0') {
					sock_fd = -1;
				}
				break;
		}
	}

	if (config_path[0] == '\0') {
		char *config_home = getenv(CONFIG_HOME_ENV);
		if (config_home != NULL) {
			snprintf(config_path, sizeof(config_path), "%s/%s/%s", config_home, WM_NAME, CONFIG_NAME);
		} else {
			snprintf(config_path, sizeof(config_path), "%s/%s/%s/%s", getenv("HOME"), ".config", WM_NAME, CONFIG_NAME);
		}
	}

	dpy = xcb_connect(NULL, &default_screen);

	if (!check_connection(dpy)) {
		exit(EXIT_FAILURE);
	}

	load_settings();
	setup();

	if (state_path[0] != '\0') {
		restore_state(state_path);
		unlink(state_path);
	}

	dpy_fd = xcb_get_file_descriptor(dpy);

	if (sock_fd == -1) {
		char *sp = getenv(SOCKET_ENV_VAR);
		if (sp != NULL) {
			snprintf(socket_path, sizeof(socket_path), "%s", sp);
		} else {
			char *host = NULL;
			int dn = 0, sn = 0;
			if (xcb_parse_display(NULL, &host, &dn, &sn) != 0) {
				snprintf(socket_path, sizeof(socket_path), SOCKET_PATH_TPL, host, dn, sn);
			}
			free(host);
		}

		sock_address.sun_family = AF_UNIX;
		if (snprintf(sock_address.sun_path, sizeof(sock_address.sun_path), "%s", socket_path) < 0) {
			err("Couldn't write the socket path.\n");
		}

		sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);

		if (sock_fd == -1) {
			err("Couldn't create the socket.\n");
		}

		unlink(socket_path);

		if (bind(sock_fd, (struct sockaddr *) &sock_address, sizeof(sock_address)) == -1) {
			err("Couldn't bind a name to the socket.\n");
		}

		if (listen(sock_fd, SOMAXCONN) == -1) {
			err("Couldn't listen to the socket.\n");
		}
	}

	fcntl(sock_fd, F_SETFD, FD_CLOEXEC | fcntl(sock_fd, F_GETFD));

	signal(SIGINT, sig_handler);
	signal(SIGHUP, sig_handler);
	signal(SIGTERM, sig_handler);
	signal(SIGCHLD, sig_handler);
	signal(SIGPIPE, SIG_IGN);
	run_config(run_level);
	running = true;

	while (running) {

		xcb_flush(dpy);

		FD_ZERO(&descriptors);
		FD_SET(sock_fd, &descriptors);
		FD_SET(dpy_fd, &descriptors);
		max_fd = MAX(sock_fd, dpy_fd);

		for (pending_rule_t *pr = pending_rule_head; pr != NULL; pr = pr->next) {
			FD_SET(pr->fd, &descriptors);
			if (pr->fd > max_fd) {
				max_fd = pr->fd;
			}
		}

		if (select(max_fd + 1, &descriptors, NULL, NULL, NULL) > 0) {

			pending_rule_t *pr = pending_rule_head;
			while (pr != NULL) {
				pending_rule_t *next = pr->next;
				if (FD_ISSET(pr->fd, &descriptors)) {
					if (manage_window(pr->win, pr->csq, pr->fd)) {
						for (event_queue_t *eq = pr->event_head; eq != NULL; eq = eq->next) {
							handle_event(&eq->event);
						}
					}
					remove_pending_rule(pr);
				}
				pr = next;
			}

			if (FD_ISSET(sock_fd, &descriptors)) {
				cli_fd = accept(sock_fd, NULL, 0);
				if (cli_fd > 0 && (n = recv(cli_fd, msg, sizeof(msg)-1, 0)) > 0) {
					msg[n] = '\0';
					FILE *rsp = fdopen(cli_fd, "w");
					if (rsp != NULL) {
						handle_message(msg, n, rsp);
					} else {
						warn("Can't open the client socket as file.\n");
						close(cli_fd);
					}
				}
			}

			if (FD_ISSET(dpy_fd, &descriptors)) {
				xcb_aux_sync(dpy);
				while ((event = xcb_poll_for_event(dpy)) != NULL) {
					handle_event(event);
					free(event);
				}
			}

		}

		if (!check_connection(dpy)) {
			running = false;
		}

		prune_dead_subscribers();
	}

	if (restart) {
		char *host = NULL;
		int dn = 0, sn = 0;
		if (xcb_parse_display(NULL, &host, &dn, &sn) != 0) {
			snprintf(state_path, sizeof(state_path), STATE_PATH_TPL, host, dn, sn);
		}
		free(host);
		FILE *f = fopen(state_path, "w");
		query_state(f);
		fclose(f);
	}

	cleanup();
	ungrab_buttons();
	xcb_ewmh_connection_wipe(ewmh);
	xcb_destroy_window(dpy, meta_window);
	xcb_destroy_window(dpy, motion_recorder.id);
	free(ewmh);
	xcb_flush(dpy);
	xcb_disconnect(dpy);

	if (restart) {
		fcntl(sock_fd, F_SETFD, ~FD_CLOEXEC & fcntl(sock_fd, F_GETFD));

		int rargc;
		for (rargc = 0; rargc < argc; rargc++) {
			if (streq("-s", argv[rargc])) {
				break;
			}
		}

		int len = rargc + 5;
		char **rargv = malloc(len * sizeof(char *));

		for (int i = 0; i < rargc; i++) {
			rargv[i] = argv[i];
		}

		char sock_fd_arg[SMALEN];
		snprintf(sock_fd_arg, sizeof(sock_fd_arg), "%i", sock_fd);

		rargv[rargc] = "-s";
		rargv[rargc + 1] = state_path;
		rargv[rargc + 2] = "-o";
		rargv[rargc + 3] = sock_fd_arg;
		rargv[rargc + 4] = 0;

		execvp(*rargv, rargv);

		exit_status = 1;
		free(rargv);
	}

	close(sock_fd);
	unlink(socket_path);

	return exit_status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2368, %rsp           # imm = 0x2368
movq %rsi, 0x20(%rsp)
movl %edi, %ebx
leaq 0x160(%rsp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x40f0
movb $0x0, 0x248b1(%rip)     # 0x295c0
leaq 0x360(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x40f0
movl %ebx, 0x1c(%rsp)
movl %ebx, %eax
movq %rax, 0x40(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rsp)
leaq 0x1a2c5(%rip), %rbx     # 0x1f004
movq 0x2429a(%rip), %r14     # 0x28fe0
leaq 0x24873(%rip), %r12     # 0x295c0
leaq 0x1a2f3(%rip), %r13     # 0x1f047
xorl %r15d, %r15d
movl %r15d, %ebp
orl $0x1, %r15d
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x4570
cmpl $0x6e, %eax
jg 0x4d90
cmpl $0x63, %eax
jne 0x4da4
movq (%r14), %rcx
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4110
jmp 0x4d5e
cmpl $0x6f, %eax
je 0x4dd2
cmpl $0x73, %eax
je 0x4db3
cmpl $0x76, %eax
jne 0x4d5e
jmp 0x5573
cmpl $-0x1, %eax
je 0x4e04
cmpl $0x68, %eax
jne 0x4d5e
jmp 0x557c
movq (%r14), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x160(%rsp), %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4110
movl %r15d, %ebp
jmp 0x4d5e
movl %ebp, %r15d
orl $0x2, %r15d
movq (%r14), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x4680
movq 0x48(%rsp), %rcx
xorl %edx, %edx
cmpb (%rcx), %dl
movl $0x0, %ecx
sbbl %ecx, %ecx
orl %eax, %ecx
movq %rcx, 0x10(%rsp)
jmp 0x4d57
cmpb $0x0, 0x247b5(%rip)     # 0x295c0
movq 0x10(%rsp), %r14
jne 0x4e83
leaq 0x1a207(%rip), %rdi     # 0x1f020
callq 0x4790
testq %rax, %rax
je 0x4e41
leaq 0x24796(%rip), %rdi     # 0x295c0
leaq 0x1a210(%rip), %rdx     # 0x1f041
leaq 0x1a1f8(%rip), %r8      # 0x1f030
leaq 0x1a1f7(%rip), %r9      # 0x1f036
jmp 0x4e74
leaq 0x1a1e3(%rip), %rdi     # 0x1f02b
callq 0x4790
leaq 0x1a1e2(%rip), %rcx     # 0x1f036
movq %rcx, (%rsp)
leaq 0x24761(%rip), %rdi     # 0x295c0
leaq 0x1a1d8(%rip), %rdx     # 0x1f03e
leaq 0x1a1dd(%rip), %r8      # 0x1f04a
leaq 0x1a1bc(%rip), %r9      # 0x1f030
movl $0x100, %esi            # imm = 0x100
movq %rax, %rcx
xorl %eax, %eax
callq 0x4110
leaq 0x24836(%rip), %rsi     # 0x296c0
xorl %edi, %edi
callq 0x43b0
movq %rax, 0x24830(%rip)     # 0x296c8
movq %rax, %rdi
callq 0x5599
testb %al, %al
je 0x558f
callq 0x6944
callq 0x55e1
cmpb $0x0, 0x160(%rsp)
je 0x4ed4
leaq 0x160(%rsp), %rbx
movq %rbx, %rdi
callq 0x1aeb4
movq %rbx, %rdi
callq 0x42e0
movq 0x247ed(%rip), %rdi     # 0x296c8
callq 0x4380
movl %eax, %r12d
cmpl $-0x1, %r14d
jne 0x5036
leaq 0x1a15e(%rip), %rdi     # 0x1f052
callq 0x4790
testq %rax, %rax
je 0x4f1e
leaq 0x1a142(%rip), %rdx     # 0x1f047
leaq 0x260(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rcx
xorl %eax, %eax
callq 0x4110
jmp 0x4f7f
leaq 0x70(%rsp), %rsi
movq $0x0, (%rsi)
xorl %eax, %eax
leaq 0xf0(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x50(%rsp), %rcx
movl %eax, (%rcx)
xorl %edi, %edi
callq 0x4910
testl %eax, %eax
je 0x4f75
movq 0x70(%rsp), %rcx
movl 0xf0(%rsp), %r8d
movl 0x50(%rsp), %r9d
leaq 0x1a0fe(%rip), %rdx     # 0x1f05f
leaq 0x260(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x4110
movq 0x70(%rsp), %rdi
callq 0x4460
leaq 0xf2(%rsp), %rdi
movw $0x1, -0x2(%rdi)
leaq 0x1a0b3(%rip), %rdx     # 0x1f047
leaq 0x260(%rsp), %rcx
movl $0x6c, %esi
xorl %eax, %eax
callq 0x4110
testl %eax, %eax
jns 0x4fba
leaq 0x1a0c6(%rip), %rdi     # 0x1f079
xorl %eax, %eax
callq 0x5c6c
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4760
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x4fe1
leaq 0x1a0c0(%rip), %rdi     # 0x1f09a
xorl %eax, %eax
callq 0x5c6c
leaq 0x260(%rsp), %rdi
callq 0x42e0
leaq 0xf0(%rsp), %rsi
movl %r14d, %edi
movl $0x6e, %edx
callq 0x49c0
cmpl $-0x1, %eax
jne 0x5016
leaq 0x1a0a8(%rip), %rdi     # 0x1f0b7
xorl %eax, %eax
callq 0x5c6c
movl %r14d, %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x44d0
cmpl $-0x1, %eax
jne 0x5036
leaq 0x1a0ad(%rip), %rdi     # 0x1f0dc
xorl %eax, %eax
callq 0x5c6c
movl %r14d, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x4ab0
orl $0x1, %eax
movl %r14d, %edi
movl $0x2, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x4ab0
leaq 0x9ee(%rip), %rbx       # 0x5a4e
movl $0x2, %edi
movq %rbx, %rsi
callq 0x4070
movl $0x1, %edi
movq %rbx, %rsi
callq 0x4070
movl $0xf, %edi
movq %rbx, %rsi
callq 0x4070
movl $0x11, %edi
movq %rbx, %rsi
callq 0x4070
movl $0x1, %r15d
movl $0x1, %esi
movl $0xd, %edi
callq 0x4070
movl %ebp, %edi
callq 0x68cc
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r14d, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, 0x38(%rsp)
sarl $0x6, %eax
leal 0x3f(%r12), %edx
testl %r12d, %r12d
cmovnsl %r12d, %edx
movl %edx, %esi
andl $-0x40, %esi
movl %r12d, %ecx
subl %esi, %ecx
shlq %cl, %r15
movb $0x1, 0x245db(%rip)     # 0x296d0
cltq
movq %rax, 0x30(%rsp)
sarl $0x6, %edx
movslq %edx, %rbp
cmpl %r12d, %r14d
movq %r14, 0x10(%rsp)
cmovgl %r14d, %r12d
movq 0x245b3(%rip), %rdi     # 0x296c8
callq 0x4660
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
orq %rax, 0x70(%rsp,%rcx,8)
orq %r15, 0x70(%rsp,%rbp,8)
movq 0x24563(%rip), %rax     # 0x296d8
movl %r12d, %edi
testq %rax, %rax
je 0x51b2
movl (%rax), %edx
leal 0x3f(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %r8d
andl $-0x40, %r8d
movl %edx, %ecx
subl %r8d, %ecx
movl $0x1, %r8d
shlq %cl, %r8
sarl $0x6, %esi
movslq %esi, %rcx
orq %r8, 0x70(%rsp,%rcx,8)
cmpl %edi, %edx
cmovgl %edx, %edi
movq 0x28(%rax), %rax
jmp 0x5178
incl %edi
leaq 0x70(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x41d0
testl %eax, %eax
jle 0x530f
movq %r15, %r14
movq 0x24501(%rip), %rbx     # 0x296d8
testq %rbx, %rbx
je 0x5231
movq 0x28(%rbx), %r13
movl (%rbx), %edx
leal 0x3f(%rdx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
sarl $0x6, %eax
cltq
movq 0x70(%rsp,%rax,8), %rax
btq %rdx, %rax
jae 0x5229
movl 0x4(%rbx), %edi
movq 0x8(%rbx), %rsi
callq 0xf836
testb %al, %al
je 0x5221
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x5221
movq %r15, %rdi
callq 0xdc7c
movq 0x30(%r15), %r15
jmp 0x520e
movq %rbx, %rdi
callq 0x1cd1a
movq %r13, %rbx
testq %r13, %r13
jne 0x51dc
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
testq %rax, 0x70(%rsp,%rcx,8)
je 0x52c1
movq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a80
testl %eax, %eax
jle 0x52c1
movl %eax, %ebx
movl $0x1fff, %edx           # imm = 0x1FFF
movl %eax, %edi
leaq 0x360(%rsp), %rsi
xorl %ecx, %ecx
callq 0x42c0
movq %rax, %r15
testl %r15d, %r15d
jle 0x52c1
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, 0x360(%rsp,%rax)
movl %ebx, %edi
leaq 0x1ba08(%rip), %rsi     # 0x20c95
callq 0x4550
testq %rax, %rax
je 0x52ac
leaq 0x360(%rsp), %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x116d4
jmp 0x52c1
leaq 0x19e49(%rip), %rdi     # 0x1f0fc
xorl %eax, %eax
callq 0x4b50
movl %ebx, %edi
callq 0x4150
movq %r14, %r15
testq %r14, 0x70(%rsp,%rbp,8)
je 0x530f
movq 0x243f6(%rip), %rdi     # 0x296c8
callq 0x40e0
movq 0x243ea(%rip), %rdi     # 0x296c8
callq 0x46c0
testq %rax, %rax
je 0x530f
movq %rax, %rbx
movq %rbx, %rdi
callq 0xdc7c
movq %rbx, %rdi
callq 0x4460
movq 0x243c6(%rip), %rdi     # 0x296c8
callq 0x46c0
movq %rax, %rbx
testq %rax, %rax
jne 0x52eb
movq 0x243b2(%rip), %rdi     # 0x296c8
callq 0x5599
testb %al, %al
jne 0x5326
movb $0x0, 0x243aa(%rip)     # 0x296d0
callq 0x1e7f8
cmpb $0x0, 0x2439e(%rip)     # 0x296d0
jne 0x510e
cmpb $0x1, 0x243a1(%rip)     # 0x296e0
movq 0x10(%rsp), %r12
jne 0x53cc
leaq 0x50(%rsp), %rsi
movq $0x0, (%rsi)
xorl %eax, %eax
leaq 0x2c(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x28(%rsp), %rcx
movl %eax, (%rcx)
xorl %edi, %edi
callq 0x4910
testl %eax, %eax
je 0x539b
movq 0x50(%rsp), %rcx
movl 0x2c(%rsp), %r8d
movl 0x28(%rsp), %r9d
leaq 0x19d9c(%rip), %rdx     # 0x1f123
leaq 0x160(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x4110
movq 0x50(%rsp), %rdi
callq 0x4460
leaq 0x1b8e9(%rip), %rsi     # 0x20c95
leaq 0x160(%rsp), %rdi
callq 0x42a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x181d0
movq %rbx, %rdi
callq 0x48c0
callq 0x5a94
callq 0xf140
leaq 0x24a53(%rip), %rbx     # 0x29e30
movq (%rbx), %r14
movq 0x8(%r14), %rdi
callq 0x4460
movq 0x18(%r14), %rdi
callq 0x4460
movq 0x242cf(%rip), %rdi     # 0x296c8
movl 0x242e5(%rip), %esi     # 0x296e4
callq 0x4130
movq 0x242bd(%rip), %rdi     # 0x296c8
movl 0x242d7(%rip), %esi     # 0x296e8
callq 0x4130
movq (%rbx), %rdi
callq 0x4460
movq 0x242a3(%rip), %rdi     # 0x296c8
callq 0x4660
movq 0x24297(%rip), %rdi     # 0x296c8
callq 0x4980
cmpb $0x1, 0x242a3(%rip)     # 0x296e0
jne 0x5546
xorl %r14d, %r14d
movl %r12d, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x4ab0
andl $-0x2, %eax
movl %r12d, %edi
movl $0x2, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x4ab0
cmpl $0x0, 0x1c(%rsp)
jle 0x54a7
xorl %r14d, %r14d
movq 0x40(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax,%r14,8), %rcx
movzbl (%rcx), %eax
subl $0x2d, %eax
jne 0x5496
movzbl 0x1(%rcx), %eax
subl $0x73, %eax
jne 0x5496
movzbl 0x2(%rcx), %eax
negl %eax
testl %eax, %eax
je 0x54a7
incq %r14
cmpq %r14, %rdx
jne 0x5478
movl %edx, %r14d
movl %r14d, %r15d
leaq 0x28(,%r15,8), %rdi
callq 0x4290
movq %rax, %rbx
testl %r14d, %r14d
je 0x54d6
leaq (,%r15,8), %rdx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x4aa0
jmp 0x54d9
xorl %r15d, %r15d
leaq 0x1bc3f(%rip), %rdx     # 0x2111f
leaq 0x50(%rsp), %r14
movl $0x20, %esi
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x4110
leaq 0x1a859(%rip), %rax     # 0x1fd57
movq %rax, (%rbx,%r15,8)
leaq 0x160(%rsp), %rax
movq %rax, 0x8(%rbx,%r15,8)
leaq 0x19c26(%rip), %rax     # 0x1f13c
movq %rax, 0x10(%rbx,%r15,8)
movq %r14, 0x18(%rbx,%r15,8)
movq $0x0, 0x20(%rbx,%r15,8)
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x41e0
movl $0x1, 0x241b2(%rip)     # 0x296f0
movq %rbx, %rdi
callq 0x4460
movl %r12d, %edi
callq 0x4150
leaq 0x260(%rsp), %rdi
callq 0x42e0
movl 0x2418f(%rip), %eax     # 0x296f0
addq $0x2368, %rsp           # imm = 0x2368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19a93(%rip), %rdi     # 0x1f00d
jmp 0x5583
leaq 0x19d58(%rip), %rdi     # 0x1f2db
callq 0x4190
xorl %edi, %edi
callq 0x41f0
movl $0x1, %edi
callq 0x41f0