LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/checker/main.cpp
// Function: symbol_counter(unsigned char*, int)
int symbol_counter(uchar* buf, int length)
{
	set<uchar> s;
	int cnt = 0;
	while (cnt < length) s.insert(buf[cnt++]);
/*
	cout << endl;
	for (auto &iter: s) cout << (int)iter << " ";
	cout << endl;
*/
	return s.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2f40
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2e55
movq -0x8(%rbp), %rsi
movslq -0x44(%rbp), %rax
movl %eax, %ecx
incl %ecx
movl %ecx, -0x44(%rbp)
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x2f60
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x2e2e
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
jmp 0x2e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fd0
jmp 0x2e76
leaq -0x40(%rbp), %rdi
callq 0x2fb0
movl %eax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fd0
movl -0x78(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2220
nop
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/checker/main.cpp
// Function: ceil_log2(int)
int ceil_log2(int n)
{
	assert (n >= 1);
	int last = -1, secondlast = -1, count = 0;
	int log2_n, tmp = n;

	while (tmp) {
	if (tmp & 1) {
		secondlast = last;
		last = count;
	}
	tmp >>= 1;
	++count;
	}
	if (secondlast == -1)
		log2_n = last;
	else
		log2_n = last+1;

	return log2_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0x2e93
jmp 0x2eb2
leaq 0x1260(%rip), %rdi      # 0x40fa
leaq 0x1260(%rip), %rsi      # 0x4101
movl $0x6c, %edx
leaq 0x1269(%rip), %rcx      # 0x4116
callq 0x20f0
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2efd
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2eea
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ecd
cmpl $-0x1, -0xc(%rbp)
jne 0x2f0b
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2f14
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_mispositions
double metric_mispositions(int *output, int n) {
  int mispos = 0;
  for(int i = 0; i < n; i++) {
    if(output[i] != i)
      mispos++;
  }

  return mispos/(double)n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1217
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
je 0x120a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x120c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11e9
cvtsi2sdl -0x10(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_distance
long metric_distance(int *output, int n) {
  long dist = 0;
  for(int i = 0; i < n; i++) {
    dist += (output[i] > i ? output[i] - i : i - output[i]);
  }

  return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x129e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jle 0x1275
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x1286
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x124a
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_kendall
double metric_kendall(int *output, int n) {
  long count = 0;
  for(int i = 0; i < n; i++) {
    for(int j = i+1; j < n; j++) {
      if(output[i] > output[j])
        count++;
    }
  }

  return 2*count / (n*(n-1.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1321
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1314
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x1307
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1309
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12db
jmp 0x1316
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12ca
movq -0x18(%rbp), %rax
shlq %rax
cvtsi2sd %rax, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm2
movsd 0x1cc9(%rip), %xmm3     # 0x3008
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_mispositions_threshold
double metric_mispositions_threshold(int *output, int n, int threshold) {
  int mispos = 0;
  for(int i = 0; i < n; i++) {
    if(output[i] > i + threshold || output[i] < i - threshold)
      mispos++;
  }

  return mispos/(double)n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13b4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jg 0x139e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
subl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x13a7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13a9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x136c
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: all_metrics_per_epsilon
void all_metrics_per_epsilon(int *elts, int n) {
  int output[n];

  for(int k = 1; k < n; k *= 2) {
    double epsilon = ((double)k)/n;
    int r = ceil(-log(epsilon)/log(2)) + 5;

    softheap *P = makeheap_empty(epsilon);

    for(int i = 0; i < n; i++)
      insert(P, elts[i]);

    for(int i = 0; i < n; i++)
      output[i] = extract_min(P);

    destroy_heap(P);

    printf("r=%d \t\t %f \t\t %ld \t\t %f \n", r, metric_mispositions(output,n),metric_distance(output,n),metric_mispositions_threshold(output,n,n/100));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1562
cvtsi2sdl -0x24(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x1060
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x1bbe(%rip), %xmm0     # 0x3018
callq 0x1060
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x10b0
movsd 0x1b98(%rip), %xmm1     # 0x3010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x1700
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14bf
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1970
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1498
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14ef
movq -0x40(%rbp), %rdi
callq 0x1d90
movl %eax, %edx
movq -0x50(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x14c6
movq -0x40(%rbp), %rdi
callq 0x1870
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0xc(%rbp), %esi
callq 0x11d0
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
movl -0xc(%rbp), %esi
callq 0x1230
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x1350
movl -0x6c(%rbp), %esi
movq -0x68(%rbp), %rdx
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
leaq 0x1ada(%rip), %rdi      # 0x3028
movb $0x2, %al
callq 0x1040
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x140d
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: random_permutation
void random_permutation(int *elts, int n) {
  for(int i = 0; i < n; i++) {
    int j = randint(i+1);
    elts[i] = elts[j];
    elts[j] = i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x160b
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x1570
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15c6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/approx-sort.c
// Function: main
int main(int argc, char *argv[]) {
  int n = 1000000;

  int elts[n];

  srand(time(NULL));
  random_permutation(elts, n);

  all_metrics_per_epsilon(elts, n);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xf4240, -0x14(%rbp)   # imm = 0xF4240
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl %eax, %edi
callq 0x1070
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15b0
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13d0
movl $0x0, -0x4(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vusec[P]fpvi-scsb/fp_reverse_engineering/test_operands/test_operands.c
// Function: print_double
void print_double(char *name, double n)
{
    int64_t  bias = 1023;
    uint64_t hex_n = *((uint64_t *)&n);
    uint64_t unbiased_exp = (hex_n>>52)&0x7FF;
    int64_t  biased_exp   = unbiased_exp == 0 ? -1022 : (int64_t)unbiased_exp - bias;
    uint64_t mantissa = hex_n&0x000FFFFFFFFFFFFFUL;
    
    printf("%9s = 0x%016lx    %16e    ", name, hex_n, n);
    printf("(%8s    biased_exp=%5ld    unbiased_exp=%5ld    mantissa=0x%013lx)\n",
            unbiased_exp == 0 ? "DENORMAL" : "  NORMAL",
            unbiased_exp, biased_exp, mantissa);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq $0x3ff, 0x30(%rsp)      # imm = 0x3FF
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
shrq $0x34, %rax
andq $0x7ff, %rax            # imm = 0x7FF
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x12ac
movq $-0x3fe, %rax           # imm = 0xFC02
movq %rax, 0x8(%rsp)
jmp 0x12bb
movq 0x20(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdx
movsd 0x38(%rsp), %xmm0
leaq 0xd27(%rip), %rdi       # 0x2017
movb $0x1, %al
callq 0x1040
movq 0x20(%rsp), %rcx
leaq 0xd7c(%rip), %rsi       # 0x207f
leaq 0xd6c(%rip), %rax       # 0x2076
cmpq $0x0, %rcx
cmoveq %rax, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
leaq 0xd0a(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1040
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: version
static void version(void)
{
	fprintf(stderr, "%s %s\n", __NAME__, __THIS_VERSION__);
	fprintf(stderr, "Copyright (c) 2016-2019 Tudor Ioan Roman\n");
	fprintf(stderr, "Released under the ISC License\n");

	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb5d5(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x87a4(%rip), %rsi      # 0xc1c9
leaq 0x875f(%rip), %rdx      # 0xc18b
leaq 0x8795(%rip), %rcx      # 0xc1c8
movb $0x0, %al
callq 0x3680
movq 0xb5af(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x8785(%rip), %rsi      # 0xc1d0
movb $0x0, %al
callq 0x3680
movq 0xb597(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x8797(%rip), %rsi      # 0xc1fa
movb $0x0, %al
callq 0x3680
xorl %edi, %edi
callq 0x3150
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: cleanup
static void
cleanup(void)
{
	xcb_set_input_focus(conn, XCB_NONE, XCB_INPUT_FOCUS_POINTER_ROOT,
			XCB_CURRENT_TIME);
	ungrab_buttons();
	if (ewmh != NULL)
		xcb_ewmh_connection_wipe(ewmh);
	if (win_list != NULL)
		list_delete_all_items(&win_list, true);
	if (focus_list != NULL)
	    list_delete_all_items(&focus_list, true);
	if (conn != NULL)
		xcb_disconnect(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xb949(%rip), %rdi      # 0xf3d8
xorl %ecx, %ecx
movl $0x1, %edx
movl %ecx, %esi
callq 0x3160
movl %eax, -0x4(%rbp)
callq 0x43a0
cmpq $0x0, 0xb933(%rip)      # 0xf3e0
je 0x3abb
movq 0xb92a(%rip), %rdi      # 0xf3e0
callq 0x4400
cmpq $0x0, 0xb925(%rip)      # 0xf3e8
je 0x3ad6
leaq 0xb91c(%rip), %rdi      # 0xf3e8
movl $0x1, %esi
callq 0xb8a0
cmpq $0x0, 0xb912(%rip)      # 0xf3f0
je 0x3af1
leaq 0xb909(%rip), %rdi      # 0xf3f0
movl $0x1, %esi
callq 0xb8a0
cmpq $0x0, 0xb8df(%rip)      # 0xf3d8
je 0x3b07
movq 0xb8d6(%rip), %rdi      # 0xf3d8
callq 0x3630
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: register_event_handlers
static void
register_event_handlers(void)
{
	for (int i = 0; i <= LAST_XCB_EVENT; i++)
		events[i] = NULL;

	events[XCB_CONFIGURE_REQUEST] = event_configure_request;
	events[XCB_DESTROY_NOTIFY]    = event_destroy_notify;
	events[XCB_ENTER_NOTIFY]      = event_enter_notify;
	events[XCB_MAP_REQUEST]       = event_map_request;
	events[XCB_MAP_NOTIFY]        = event_map_notify;
	events[XCB_UNMAP_NOTIFY]      = event_unmap_notify;
	events[XCB_CLIENT_MESSAGE]    = event_client_message;
	events[XCB_CONFIGURE_NOTIFY]  = event_configure_notify;
	events[XCB_CIRCULATE_REQUEST] = event_circulate_request;
	events[XCB_FOCUS_IN]          = event_focus_in;
	events[XCB_FOCUS_OUT]         = event_focus_out;
	events[XCB_BUTTON_PRESS]      = event_button_press;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x77, -0x4(%rbp)
jg 0x3b3f
movslq -0x4(%rbp), %rcx
leaq 0xb8d4(%rip), %rax      # 0xf400
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b1b
leaq 0x8ea(%rip), %rax       # 0x4430
movq %rax, 0xb96b(%rip)      # 0xf4b8
leaq 0xc2c(%rip), %rax       # 0x4780
movq %rax, 0xb92d(%rip)      # 0xf488
leaq 0xc9e(%rip), %rax       # 0x4800
movq %rax, 0xb8cf(%rip)      # 0xf438
leaq 0xd00(%rip), %rax       # 0x4870
movq %rax, 0xb929(%rip)      # 0xf4a0
leaq 0xf22(%rip), %rax       # 0x4aa0
movq %rax, 0xb913(%rip)      # 0xf498
leaq 0xf64(%rip), %rax       # 0x4af0
movq %rax, 0xb8fd(%rip)      # 0xf490
leaq 0xfe6(%rip), %rax       # 0x4b80
movq %rax, 0xb967(%rip)      # 0xf508
leaq 0x10d8(%rip), %rax      # 0x4c80
movq %rax, 0xb901(%rip)      # 0xf4b0
leaq 0x11ea(%rip), %rax      # 0x4da0
movq %rax, 0xb91b(%rip)      # 0xf4d8
leaq 0x121c(%rip), %rax      # 0x4de0
movq %rax, 0xb87d(%rip)      # 0xf448
leaq 0x125e(%rip), %rax      # 0x4e30
movq %rax, 0xb877(%rip)      # 0xf450
leaq 0x1300(%rip), %rax      # 0x4ee0
movq %rax, 0xb839(%rip)      # 0xf420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: load_defaults
static void
load_defaults(void)
{
	conf.border_width    = BORDER_WIDTH;
	conf.focus_color     = COLOR_FOCUS;
	conf.unfocus_color   = COLOR_UNFOCUS;
	conf.internal_border_width    = INTERNAL_BORDER_WIDTH;
	conf.internal_focus_color     = INTERNAL_COLOR_FOCUS;
	conf.internal_unfocus_color   = INTERNAL_COLOR_UNFOCUS;
	conf.gap_left = conf.gap_down
		= conf.gap_up = conf.gap_right = GAP;
	conf.grid_gap        = GRID_GAP;
	conf.cursor_position = CURSOR_POSITION;
	conf.groups          = GROUPS;
	conf.sloppy_focus    = SLOPPY_FOCUS;
	conf.resize_hints    = RESIZE_HINTS;
	conf.sticky_windows  = STICKY_WINDOWS;
	conf.borders         = BORDERS;
	conf.last_window_focusing = LAST_WINDOW_FOCUSING;
	conf.apply_settings       = APPLY_SETTINGS;
	conf.replay_click_on_focus = REPLAY_CLICK_ON_FOCUS;
	conf.pointer_actions[BUTTON_LEFT]   = DEFAULT_LEFT_BUTTON_ACTION;
	conf.pointer_actions[BUTTON_MIDDLE] = DEFAULT_MIDDLE_BUTTON_ACTION;
	conf.pointer_actions[BUTTON_RIGHT]  = DEFAULT_RIGHT_BUTTON_ACTION;
	conf.pointer_modifier = POINTER_MODIFIER;
	conf.click_to_focus = CLICK_TO_FOCUS_BUTTON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x5, 0xba15(%rip)      # 0xf7c0
movl $0x97a293, 0xba13(%rip) # imm = 0x97A293
movl $0x393638, 0xba0d(%rip) # imm = 0x393638
movb $0x0, 0xb9fb(%rip)      # 0xf7c1
movl $0x393638, 0xba00(%rip) # imm = 0x393638
movl $0x97a293, 0xb9fa(%rip) # imm = 0x97A293
movb $0x0, 0xb9e5(%rip)      # 0xf7c6
movb $0x0, 0xb9dd(%rip)      # 0xf7c5
movb $0x0, 0xb9d5(%rip)      # 0xf7c4
movb $0x0, 0xb9cd(%rip)      # 0xf7c3
movb $0x0, 0xb9c5(%rip)      # 0xf7c2
movl $0x4, 0xb9d1(%rip)      # 0xf7d8
movl $0xa, 0xb9cb(%rip)      # 0xf7dc
movb $0x1, 0xb9c8(%rip)      # 0xf7e0
movb $0x0, 0xb9c2(%rip)      # 0xf7e1
movb $0x0, 0xb9bc(%rip)      # 0xf7e2
movb $0x1, 0xb9b6(%rip)      # 0xf7e3
movb $0x1, 0xb9b0(%rip)      # 0xf7e4
movb $0x1, 0xb9aa(%rip)      # 0xf7e5
movb $0x1, 0xb9a4(%rip)      # 0xf7e6
movl $0x2, 0xb99c(%rip)      # 0xf7e8
movl $0x4, 0xb996(%rip)      # 0xf7ec
movl $0x3, 0xb990(%rip)      # 0xf7f0
movw $0x40, 0xb98b(%rip)     # 0xf7f4
movb $0x0, 0xb986(%rip)      # 0xf7f6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: load_config
static void
load_config(char *config_path)
{
	int f = fork();
	if (f == 0) {
		setsid();
		DMSG("loading %s\n", config_path);
		execl(config_path, config_path, NULL);
		err(EXIT_FAILURE, "couldn't load config file");
	} else if (f == -1) {
		err(EXIT_FAILURE, NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3640
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x42b5
callq 0x30c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x3190
movl $0x1, %edi
leaq 0x810e(%rip), %rsi      # 0xc3bc
movb $0x0, %al
callq 0x3430
cmpl $-0x1, -0xc(%rbp)
jne 0x42cb
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x3430
jmp 0x42cd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: run
static void
run(void)
{
	xcb_generic_event_t *ev;

	update_group_list();
	halt = false;
	exit_code = EXIT_SUCCESS;
	while (!halt) {
		xcb_flush(conn);
		ev = xcb_wait_for_event(conn);
		if (ev) {
			DMSG("X Event %d\n", ev->response_type & ~0x80);
			if (ev->response_type == randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
				get_randr();
				DMSG("Screen layout changed\n");
			}
			if (events[EVENT_MASK(ev->response_type)] != NULL)
				(events[EVENT_MASK(ev->response_type)])(ev);
			free(ev);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6850
movb $0x0, 0xb63c(%rip)      # 0xf930
movl $0x0, 0xb0d2(%rip)      # 0xf3d0
movb 0xb62c(%rip), %al       # 0xf930
xorb $-0x1, %al
testb $0x1, %al
jne 0x430f
jmp 0x4396
movq 0xb0c2(%rip), %rdi      # 0xf3d8
callq 0x3400
movq 0xb0b6(%rip), %rdi      # 0xf3d8
callq 0x33d0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4391
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl 0xb4ed(%rip), %ecx      # 0xf82c
addl $0x0, %ecx
cmpl %ecx, %eax
jne 0x434b
callq 0x7790
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movslq %eax, %rcx
leaq 0xb09f(%rip), %rax      # 0xf400
cmpq $0x0, (%rax,%rcx,8)
je 0x4388
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movslq %eax, %rcx
leaq 0xb082(%rip), %rax      # 0xf400
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x32d0
jmp 0x42fe
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ungrab_buttons
static void
ungrab_buttons(void)
{
	struct list_item *item;
	struct client *client;

	for (item = win_list; item != NULL; item = item->next) {
		client = item->data;
		xcb_ungrab_button(conn, XCB_BUTTON_INDEX_ANY, client->window, XCB_MOD_MASK_ANY);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xb039(%rip), %rax      # 0xf3e8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43ef
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq 0xb00c(%rip), %rdi      # 0xf3d8
movq -0x10(%rbp), %rax
movl (%rax), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0x3500
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x43b3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_destroy_notify
static void
event_destroy_notify(xcb_generic_event_t *ev)
{
	struct client *client;
	xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *)ev;

	client = find_client(&e->window);
	if (conf.last_window_focusing && focused_win != NULL && focused_win == client) {
	    focused_win = NULL;
		set_focused_last_best();
	}

	if (client != NULL) {
		free_window(client);
	}


	update_client_list();
	update_group_list();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ff0
movq %rax, -0x10(%rbp)
testb $0x1, 0xb038(%rip)      # 0xf7e4
je 0x47d5
cmpq $0x0, 0xb04a(%rip)      # 0xf800
je 0x47d5
movq 0xb041(%rip), %rax      # 0xf800
cmpq -0x10(%rbp), %rax
jne 0x47d5
movq $0x0, 0xb030(%rip) # 0xf800
callq 0x69a0
cmpq $0x0, -0x10(%rbp)
je 0x47e5
movq -0x10(%rbp), %rdi
callq 0x66f0
callq 0x6750
callq 0x6850
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_enter_notify
static void
event_enter_notify(xcb_generic_event_t *ev)
{
	xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *)ev;
	struct client *client;

	if (conf.sloppy_focus == false)
		return;

	if (focused_win != NULL && e->event == focused_win->window)
		return;

	client = find_client(&e->event);

	if (client != NULL)
		set_focused_no_raise(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0xafc6(%rip), %al       # 0xf7e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4826
jmp 0x4865
cmpq $0x0, 0xafd2(%rip)      # 0xf800
je 0x4844
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq 0xafc2(%rip), %rcx      # 0xf800
cmpl (%rcx), %eax
jne 0x4844
jmp 0x4865
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
callq 0x4ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4865
movq -0x18(%rbp), %rdi
callq 0x5920
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_map_notify
static void
event_map_notify(xcb_generic_event_t *ev)
{
	xcb_map_notify_event_t *e = (xcb_map_notify_event_t *)ev;
	struct client *client = find_client(&e->window);

	if (client != NULL) {
		client->mapped = true;
		set_focused(client);
		update_window_status(client);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ae6
movq -0x18(%rbp), %rax
movb $0x1, 0x54(%rax)
movq -0x18(%rbp), %rdi
callq 0x6a10
movq -0x18(%rbp), %rdi
callq 0x5b70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_unmap_notify
static void
event_unmap_notify(xcb_generic_event_t *ev)
{
	xcb_map_request_event_t *e = (xcb_map_request_event_t *)ev;
	struct client *client = NULL;

	client = find_client(&e->window);
	if (client == NULL)
		return;

	client->mapped = false;

	if (conf.last_window_focusing && focused_win != NULL && client->window == focused_win->window) {
		focused_win = NULL;
		set_focused_last_best();
	}

	update_client_list();
	update_window_status(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b26
jmp 0x4b70
movq -0x18(%rbp), %rax
movb $0x0, 0x54(%rax)
testb $0x1, 0xacaf(%rip)      # 0xf7e4
je 0x4b62
cmpq $0x0, 0xacc1(%rip)      # 0xf800
je 0x4b62
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq 0xacb2(%rip), %rcx      # 0xf800
cmpl (%rcx), %eax
jne 0x4b62
movq $0x0, 0xaca3(%rip) # 0xf800
callq 0x69a0
callq 0x6750
movq -0x18(%rbp), %rdi
callq 0x5b70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_client_message
static void
event_client_message(xcb_generic_event_t *ev)
{
	xcb_client_message_event_t *e = (xcb_client_message_event_t *)ev;
	uint32_t ipc_command;
	uint32_t *data;
	struct client *client;

	if (e->type == ATOMS[_IPC_ATOM_COMMAND] && e->format == 32) {
		/* Message from the client */
		data = e->data.data32;
		ipc_command = data[0];
		if (ipc_handlers[ipc_command] != NULL)
			(ipc_handlers[ipc_command])(data + 1);
		DMSG("IPC Command %u with arguments %u %u %u\n", ipc_command, data[1], data[2], data[3]);
	} else {
		client = find_client(&e->window);
		if (client == NULL)
			return;
		if (e->type == ewmh->_NET_WM_STATE) {
			DMSG("got _NET_WM_STATE for 0x%08x\n", client->window);
			handle_wm_state(client, e->data.data32[1], e->data.data32[0]);
			handle_wm_state(client, e->data.data32[2], e->data.data32[0]);
		} else if (e->type == ewmh->_NET_ACTIVE_WINDOW) {
			DMSG("got _NET_ACTIVE_WINDOW for 0x%08x\n", client->window);
			set_focused(client);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0xac77(%rip), %eax      # 0xf818
jne 0x4bf7
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x4bf7
movq -0x10(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xac6f(%rip), %rax      # 0xf840
cmpq $0x0, (%rax,%rcx,8)
je 0x4bf2
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xac5c(%rip), %rax      # 0xf840
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
jmp 0x4c77
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x4ff0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4c11
jmp 0x4c77
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq 0xa7c1(%rip), %rcx      # 0xf3e0
cmpl 0x84(%rcx), %eax
jne 0x4c57
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x7380
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x7380
jmp 0x4c75
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq 0xa77b(%rip), %rcx      # 0xf3e0
cmpl 0x40(%rcx), %eax
jne 0x4c73
movq -0x28(%rbp), %rdi
callq 0x6a10
jmp 0x4c75
jmp 0x4c77
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_configure_notify
static void
event_configure_notify(xcb_generic_event_t *ev)
{
	xcb_configure_notify_event_t *e = (xcb_configure_notify_event_t *)ev;
	struct client *client;
	struct list_item *item;

	/* The root window changes its geometry when the
	 * user adds/removes/tilts screens */
	if (e->window == scr->root) {
		if (e->width != scr->width_in_pixels
				|| e->height != scr->height_in_pixels) {
			scr->width_in_pixels = e->width;
			scr->height_in_pixels = e->height;

			if (randr_base != -1) {
				get_randr();
				for (item = win_list; item != NULL; item = item->next) {
					client = item->data;
					fit_on_screen(client);
				}
			}
		}
	} else {
		client = find_client(&e->window);
		if (client != NULL) {
			client->monitor = find_monitor_by_coord(client->geom.x, client->geom.y);
			update_current_desktop(client);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq 0xab56(%rip), %rcx      # 0xf7f8
cmpl (%rcx), %eax
jne 0x4d46
movq -0x10(%rbp), %rax
movzwl 0x14(%rax), %eax
movq 0xab3f(%rip), %rcx      # 0xf7f8
movzwl 0x14(%rcx), %ecx
cmpl %ecx, %eax
jne 0x4cd8
movq -0x10(%rbp), %rax
movzwl 0x16(%rax), %eax
movq 0xab28(%rip), %rcx      # 0xf7f8
movzwl 0x16(%rcx), %ecx
cmpl %ecx, %eax
je 0x4d44
movq -0x10(%rbp), %rax
movw 0x14(%rax), %cx
movq 0xab11(%rip), %rax      # 0xf7f8
movw %cx, 0x14(%rax)
movq -0x10(%rbp), %rax
movw 0x16(%rax), %cx
movq 0xaafe(%rip), %rax      # 0xf7f8
movw %cx, 0x16(%rax)
cmpl $-0x1, 0xab27(%rip)     # 0xf82c
je 0x4d42
callq 0x7790
movq 0xa6d5(%rip), %rax      # 0xf3e8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4d40
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5060
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4d17
jmp 0x4d42
jmp 0x4d44
jmp 0x4d8c
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4d8a
movq -0x18(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x18(%rbp), %rax
movswl %cx, %edi
movswl 0x6(%rax), %esi
callq 0x7000
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdi
callq 0x7210
jmp 0x4d8c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_focus_in
static void
event_focus_in(xcb_generic_event_t *ev)
{
	xcb_focus_in_event_t *e = (xcb_focus_in_event_t *)ev;
	xcb_window_t win = e->event;
	struct client *client = find_client(&win);

	if (client != NULL)
		update_current_desktop(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x4ff0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4e1b
movq -0x20(%rbp), %rdi
callq 0x7210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_focus_out
static void
event_focus_out(xcb_generic_event_t *ev)
{
	(void)(ev);
	xcb_get_input_focus_reply_t *focus = xcb_get_input_focus_reply(conn,
			xcb_get_input_focus(conn), NULL);
	struct client *client = NULL;

	if (focused_win != NULL && focus->focus == focused_win->window)
		return;

	if (focus->focus == scr->root) {
		focused_win = NULL;
	} else {
		client = find_client(&focus->focus);
		if (client != NULL)
			set_focused_no_raise(client);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa595(%rip), %rax      # 0xf3d8
movq %rax, -0x28(%rbp)
movq 0xa58a(%rip), %rdi      # 0xf3d8
callq 0x3610
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x36e0
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, 0xa986(%rip)      # 0xf800
je 0x4e90
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq 0xa976(%rip), %rcx      # 0xf800
cmpl (%rcx), %eax
jne 0x4e90
jmp 0x4ed2
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq 0xa95a(%rip), %rcx      # 0xf7f8
cmpl (%rcx), %eax
jne 0x4eaf
movq $0x0, 0xa953(%rip) # 0xf800
jmp 0x4ed2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ff0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4ed0
movq -0x20(%rbp), %rdi
callq 0x5920
jmp 0x4ed2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: event_button_press
static void
event_button_press(xcb_generic_event_t *ev)
{
	xcb_button_press_event_t *e = (xcb_button_press_event_t *)ev;
	bool replay = false;

	for (int i = 0; i < NR_BUTTONS; i++) {
		if (e->detail != mouse_buttons[i])
			continue;
		if ((conf.click_to_focus == (int8_t) XCB_BUTTON_INDEX_ANY ||
			 conf.click_to_focus == (int8_t) mouse_buttons[i]) &&
			(e->state & ~(num_lock | scroll_lock | caps_lock)) == XCB_NONE) {

			replay = !pointer_grab(POINTER_ACTION_FOCUS);
		} else {
			pointer_grab(conf.pointer_actions[i]);
		}
	}
	xcb_allow_events(conn, replay ? XCB_ALLOW_REPLAY_POINTER : XCB_ALLOW_SYNC_POINTER, e->time);
	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x4fb0
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movslq -0x18(%rbp), %rdx
leaq 0x71c8(%rip), %rcx      # 0xc0e4
cmpl (%rcx,%rdx,4), %eax
je 0x4f23
jmp 0x4fa2
movsbl 0xa8cc(%rip), %eax      # 0xf7f6
cmpl $0x0, %eax
je 0x4f4b
movsbl 0xa8c0(%rip), %eax      # 0xf7f6
movslq -0x18(%rbp), %rdx
leaq 0x71a3(%rip), %rcx      # 0xc0e4
movl (%rcx,%rdx,4), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4f8c
movq -0x10(%rbp), %rax
movzwl 0x1c(%rax), %eax
movzwl 0xa8ae(%rip), %ecx      # 0xf808
movzwl 0xa8ab(%rip), %edx      # 0xf80c
orl %edx, %ecx
movzwl 0xa8a0(%rip), %edx      # 0xf80a
orl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cltq
cmpq $0x0, %rax
jne 0x4f8c
movl $0x1, %edi
callq 0x7ea0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x4fa0
movslq -0x18(%rbp), %rcx
leaq 0xa829(%rip), %rax      # 0xf7c0
movl 0x28(%rax,%rcx,4), %edi
callq 0x7ea0
jmp 0x4fa2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4eff
movq 0xa421(%rip), %rdi      # 0xf3d8
movb -0x11(%rbp), %dl
movl $0x1, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %edx
movzbl %al, %esi
callq 0x30e0
movl %eax, -0x1c(%rbp)
movq 0xa3f5(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: find_client
static struct client*
find_client(xcb_window_t *win)
{
	struct list_item *item;

	item = win_list;
	while (item != NULL && ((struct client *)item->data)->window != *win)
		item = item ->next;

	if (item == NULL)
		return NULL;
	else
		return item->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0xa3e9(%rip), %rax      # 0xf3e8
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x5024
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x502d
jmp 0x503b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5003
cmpq $0x0, -0x18(%rbp)
jne 0x504c
movq $0x0, -0x8(%rbp)
jmp 0x5057
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: teleport_window
static void
teleport_window(xcb_window_t win, int16_t x, int16_t y)
{
	uint32_t values[2] = {x, y};

	if (win == scr->root || win == 0)
		return;

	xcb_configure_window(conn, win, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);
	update_window_status(find_client(&win));

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movswl -0x6(%rbp), %eax
movl %eax, -0x10(%rbp)
movswl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movq 0xa367(%rip), %rcx      # 0xf7f8
cmpl (%rcx), %eax
je 0x549b
cmpl $0x0, -0x4(%rbp)
jne 0x549d
jmp 0x54d5
movq 0x9f34(%rip), %rdi      # 0xf3d8
movl -0x4(%rbp), %esi
leaq -0x10(%rbp), %rcx
movl $0x3, %edx
callq 0x3200
movl %eax, -0x14(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x4ff0
movq %rax, %rdi
callq 0x5b70
movq 0x9f08(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: resize_window_absolute
static void
resize_window_absolute(xcb_window_t win, uint16_t w, uint16_t h)
{
	uint32_t val[2];
	uint32_t mask = XCB_CONFIG_WINDOW_WIDTH
				  | XCB_CONFIG_WINDOW_HEIGHT;

	val[0] = w;
	val[1] = h;

	xcb_configure_window(conn, win, mask, val);
	update_window_status(find_client(&win));
	refresh_borders();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movl $0xc, -0x14(%rbp)
movzwl -0x6(%rbp), %eax
movl %eax, -0x10(%rbp)
movzwl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x9ec3(%rip), %rdi      # 0xf3d8
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %eax
leaq -0x10(%rbp), %rcx
movzwl %ax, %edx
callq 0x3200
movl %eax, -0x18(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x4ff0
movq %rax, %rdi
callq 0x5b70
callq 0x6660
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: get_monitor_size
static void
get_monitor_size(struct client *client, int16_t *mon_x, int16_t *mon_y, uint16_t *mon_width, uint16_t *mon_height)
{
	if (client == NULL || client->monitor == NULL) {
		if (mon_x != NULL && mon_y != NULL)
			*mon_x = *mon_y = 0;
		if (mon_width != NULL)
			*mon_width = scr->width_in_pixels;
		if (mon_height != NULL)
			*mon_height = scr->height_in_pixels;
	} else {
		if (mon_x != NULL)
			*mon_x = client->monitor->x;
		if (mon_y != NULL)
			*mon_y = client->monitor->y;
		if (mon_width != NULL)
			*mon_width = client->monitor->width;
		if (mon_height != NULL)
			*mon_height = client->monitor->height;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x557a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x55ce
cmpq $0x0, -0x10(%rbp)
je 0x559a
cmpq $0x0, -0x18(%rbp)
je 0x559a
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
movq -0x10(%rbp), %rax
movw $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x55b3
movq 0xa250(%rip), %rax      # 0xf7f8
movw 0x14(%rax), %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x55cc
movq 0xa237(%rip), %rax      # 0xf7f8
movw 0x16(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
jmp 0x5638
cmpq $0x0, -0x10(%rbp)
je 0x55e8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movw 0x10(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x5602
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movw 0x12(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x561c
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movw 0x14(%rax), %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x5636
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movw 0x16(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
jmp 0x5638
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: maximize_window
static void
maximize_window(struct client *client, int16_t mon_x, int16_t mon_y, uint16_t mon_width, uint16_t mon_height)
{
	uint32_t values[1];
	if (client == NULL)
		return;

	if (is_special(client))
		reset_window(client);

	client->maxed = true;

	/* maximized windows don't have borders */
	values[0] = 0;
	if (client->geom.width != mon_width || client->geom.height != mon_height)
		client->orig_geom = client->geom;
	xcb_configure_window(conn, client->window, XCB_CONFIG_WINDOW_BORDER_WIDTH,
			values);

	client->geom.x = mon_x;
	client->geom.y = mon_y;
	client->geom.width = mon_width;
	client->geom.height = mon_height;

	teleport_window(client->window, client->geom.x, client->geom.y);
	resize_window_absolute(client->window, client->geom.width, client->geom.height);
	set_focused_no_raise(client);

	update_ewmh_wm_state(client);
	update_window_status(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x566c
jmp 0x5770
movq -0x8(%rbp), %rdi
callq 0x5780
testb $0x1, %al
jne 0x567b
jmp 0x5684
movq -0x8(%rbp), %rdi
callq 0x57f0
movq -0x8(%rbp), %rax
movb $0x1, 0x24(%rax)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jne 0x56b3
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movzwl -0x10(%rbp), %ecx
cmpl %ecx, %eax
je 0x56cb
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x4(%rcx), %rdx
movq %rdx, 0xe(%rax)
movw 0xc(%rcx), %cx
movw %cx, 0x16(%rax)
movq 0x9d06(%rip), %rdi      # 0xf3d8
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq -0x14(%rbp), %rcx
movl $0x10, %edx
callq 0x3200
movl %eax, -0x18(%rbp)
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movw -0xc(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movw -0xe(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movw -0x10(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x8(%rbp), %rax
movswl %cx, %esi
movswl 0x6(%rax), %edx
callq 0x5460
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x8(%rbp), %rax
movzwl %cx, %esi
movzwl 0xa(%rax), %edx
callq 0x54e0
movq -0x8(%rbp), %rdi
callq 0x5920
movq -0x8(%rbp), %rdi
callq 0x5ab0
movq -0x8(%rbp), %rdi
callq 0x5b70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: is_special
static bool
is_special(struct client *client)
{
	if (client == NULL)
		return false;

	return client->maxed
		|| client->vmaxed
		|| client->hmaxed
		|| client->monocled
		|| client->gridded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5795
movb $0x0, -0x1(%rbp)
jmp 0x57e3
movq -0x10(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x24(%rcx)
movb %al, -0x11(%rbp)
jne 0x57db
movq -0x10(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x26(%rcx)
movb %al, -0x11(%rbp)
jne 0x57db
movq -0x10(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x25(%rcx)
movb %al, -0x11(%rbp)
jne 0x57db
movq -0x10(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x27(%rcx)
movb %al, -0x11(%rbp)
jne 0x57db
movq -0x10(%rbp), %rax
movb 0x28(%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: reset_window
static void
reset_window(struct client *client)
{
	xcb_atom_t state[] = {
		XCB_ICCCM_WM_STATE_NORMAL,
		XCB_NONE
	};
	client->geom.x = client->orig_geom.x;
	client->geom.y = client->orig_geom.y;
	client->geom.width = client->orig_geom.width;
	client->geom.height = client->orig_geom.height;
	client->maxed = client->hmaxed
		= client->vmaxed = client->monocled = client->gridded = false;

	teleport_window(client->window, client->geom.x, client->geom.y);
	resize_window_absolute(client->window, client->geom.width, client->geom.height);
	set_borders(client, conf.unfocus_color, conf.internal_unfocus_color);

	xcb_change_property(conn, XCB_PROP_MODE_REPLACE, client->window,
			ewmh->_NET_WM_STATE, ewmh->_NET_WM_STATE, 32, 2, state);
	update_window_status(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6bd5(%rip), %rax      # 0xc3d8
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xe(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movw 0x10(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movq -0x8(%rbp), %rax
movw 0x12(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movw 0x14(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x27(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x26(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x25(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x8(%rbp), %rax
movswl %cx, %esi
movswl 0x6(%rax), %edx
callq 0x5460
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x8(%rbp), %rax
movzwl %cx, %esi
movzwl 0xa(%rax), %edx
callq 0x54e0
movq -0x8(%rbp), %rdi
movl 0x9f17(%rip), %esi      # 0xf7cc
movl 0x9f19(%rip), %edx      # 0xf7d4
callq 0x5d90
movq 0x9b11(%rip), %rdi      # 0xf3d8
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq 0x9b0c(%rip), %rax      # 0xf3e0
movl 0x84(%rax), %ecx
movq 0x9aff(%rip), %rax      # 0xf3e0
movl 0x84(%rax), %r8d
leaq -0x10(%rbp), %rax
xorl %esi, %esi
movl $0x20, %r9d
movl $0x2, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x35b0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b70
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: update_ewmh_wm_state
static void
update_ewmh_wm_state(struct client *client)
{
	int i;
	uint32_t values[12];

	if (client == NULL)
		return;
#define HANDLE_WM_STATE(s) \
	values[i] = ewmh->_NET_WM_STATE_##s; \
	i++; \
	DMSG("ewmh net_wm_state %s present\n", #s);

	i = 0;
	if (client->maxed) {
		HANDLE_WM_STATE(FULLSCREEN);
	}
	if (client->vmaxed) {
		HANDLE_WM_STATE(MAXIMIZED_VERT);
	}
	if (client->hmaxed) {
		HANDLE_WM_STATE(MAXIMIZED_HORZ);
	}

	xcb_ewmh_set_wm_state(ewmh, client->window, i, values);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5ac8
jmp 0x5b63
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x5af7
movq 0x9900(%rip), %rax      # 0xf3e0
movl 0x128(%rax), %ecx
movslq -0xc(%rbp), %rax
movl %ecx, -0x40(%rbp,%rax,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x26(%rax)
je 0x5b1f
movq 0x98d8(%rip), %rax      # 0xf3e0
movl 0x110(%rax), %ecx
movslq -0xc(%rbp), %rax
movl %ecx, -0x40(%rbp,%rax,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x25(%rax)
je 0x5b47
movq 0x98b0(%rip), %rax      # 0xf3e0
movl 0x114(%rax), %ecx
movslq -0xc(%rbp), %rax
movl %ecx, -0x40(%rbp,%rax,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x9892(%rip), %rdi      # 0xf3e0
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0xc(%rbp), %edx
leaq -0x40(%rbp), %rcx
callq 0x3560
movl %eax, -0x44(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)