LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohashDecodeToLongLatType
int geohashDecodeToLongLatType(const GeoHashBits hash, double *xy) {
    GeoHashArea area = { { 0 } };
    if (!xy || !geohashDecodeType(hash, &area))
        return 0;
    return geohashDecodeAreaToLongLat(&area, xy);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x10(%rsp)
movapd %xmm0, (%rsp)
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x8e191
movq %rdx, %rbx
movzbl %sil, %esi
movq %rsp, %rdx
callq 0x8e0d4
testl %eax, %eax
je 0x8e191
movapd 0x10(%rsp), %xmm0
movupd 0x18(%rsp), %xmm1
movhpd 0x28(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
addpd %xmm1, %xmm0
mulpd 0x34fc6(%rip), %xmm0    # 0xc3150
movupd %xmm0, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohashNeighbors
void geohashNeighbors(const GeoHashBits *hash, GeoHashNeighbors *neighbors) {
    neighbors->east = *hash;
    neighbors->west = *hash;
    neighbors->north = *hash;
    neighbors->south = *hash;
    neighbors->south_east = *hash;
    neighbors->south_west = *hash;
    neighbors->north_east = *hash;
    neighbors->north_west = *hash;

    geohash_move_x(&neighbors->east, 1);
    geohash_move_y(&neighbors->east, 0);

    geohash_move_x(&neighbors->west, -1);
    geohash_move_y(&neighbors->west, 0);

    geohash_move_x(&neighbors->south, 0);
    geohash_move_y(&neighbors->south, -1);

    geohash_move_x(&neighbors->north, 0);
    geohash_move_y(&neighbors->north, 1);

    geohash_move_x(&neighbors->north_west, -1);
    geohash_move_y(&neighbors->north_west, 1);

    geohash_move_x(&neighbors->north_east, 1);
    geohash_move_y(&neighbors->north_east, 1);

    geohash_move_x(&neighbors->south_east, 1);
    geohash_move_y(&neighbors->south_east, -1);

    geohash_move_x(&neighbors->south_west, -1);
    geohash_move_y(&neighbors->south_west, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
leaq 0x10(%rsi), %rax
movups (%rdi), %xmm0
movups %xmm0, 0x10(%rsi)
leaq 0x20(%rsi), %r14
movups (%rdi), %xmm0
movups %xmm0, 0x20(%rsi)
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
leaq 0x30(%rsi), %rcx
movq %rcx, (%rsp)
movups (%rdi), %xmm0
movups %xmm0, 0x30(%rsi)
leaq 0x50(%rsi), %rcx
movq %rcx, 0x8(%rsp)
movups (%rdi), %xmm0
movups %xmm0, 0x50(%rsi)
leaq 0x70(%rsi), %rcx
movq %rcx, 0x10(%rsp)
movups (%rdi), %xmm0
movups %xmm0, 0x70(%rsi)
leaq 0x40(%rsi), %r15
movups (%rdi), %xmm0
movups %xmm0, 0x40(%rsi)
leaq 0x60(%rsi), %rbx
movups (%rdi), %xmm0
movups %xmm0, 0x60(%rsi)
pushq $0x1
popq %r13
movq %rax, %rdi
movl %r13d, %esi
callq 0x8e2ac
pushq $-0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x8e2ac
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x8e30c
movq %r12, %rdi
movl %r13d, %esi
callq 0x8e30c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e2ac
movq %rbx, %rdi
movl %r13d, %esi
callq 0x8e30c
movq %r15, %rdi
movl %r13d, %esi
callq 0x8e2ac
movq %r15, %rdi
movl %r13d, %esi
callq 0x8e30c
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x8e2ac
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e30c
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e2ac
movq %rbx, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8e30c
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohash_move_x
static void geohash_move_x(GeoHashBits *hash, int8_t d) {
    if (d == 0)
        return;

    uint64_t x = hash->bits & 0xaaaaaaaaaaaaaaaaULL;
    uint64_t y = hash->bits & 0x5555555555555555ULL;

    uint64_t zz = 0x5555555555555555ULL >> (64 - hash->step * 2);

    if (d > 0) {
        x = x + (zz + 1);
    } else {
        x = x | zz;
        x = x - (zz + 1);
    }

    x &= (0xaaaaaaaaaaaaaaaaULL >> (64 - hash->step * 2));
    hash->bits = (x | y);
}

// Assembly:
testb %sil, %sil
je 0x8e30b
movabsq $-0x5555555555555556, %rdx # imm = 0xAAAAAAAAAAAAAAAA
movq (%rdi), %r8
movq %r8, %r10
andq %rdx, %r10
movabsq $0x5555555555555555, %r9 # imm = 0x5555555555555555
andq %r9, %r8
movzbl 0x8(%rdi), %ecx
addl %ecx, %ecx
pushq $0x40
popq %rax
subl %ecx, %eax
negl %ecx
shrq %cl, %r9
testb %sil, %sil
jle 0x8e2ef
leaq (%r9,%r10), %rsi
incq %rsi
jmp 0x8e2fd
orq %r10, %r9
movq %rdx, %rsi
movl %eax, %ecx
sarq %cl, %rsi
addq %r9, %rsi
movl %eax, %ecx
shrq %cl, %rdx
andq %rsi, %rdx
orq %r8, %rdx
movq %rdx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohash_move_y
static void geohash_move_y(GeoHashBits *hash, int8_t d) {
    if (d == 0)
        return;

    uint64_t x = hash->bits & 0xaaaaaaaaaaaaaaaaULL;
    uint64_t y = hash->bits & 0x5555555555555555ULL;

    uint64_t zz = 0xaaaaaaaaaaaaaaaaULL >> (64 - hash->step * 2);
    if (d > 0) {
        y = y + (zz + 1);
    } else {
        y = y | zz;
        y = y - (zz + 1);
    }
    y &= (0x5555555555555555ULL >> (64 - hash->step * 2));
    hash->bits = (x | y);
}

// Assembly:
testb %sil, %sil
je 0x8e357
movq (%rdi), %rax
movabsq $-0x5555555555555556, %rdx # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, %r8
andq %rdx, %r8
movabsq $0x5555555555555555, %r9 # imm = 0x5555555555555555
andq %r9, %rax
movb 0x8(%rdi), %cl
addb %cl, %cl
negb %cl
shrq %cl, %rdx
leaq -0x1(%rax), %r10
testb %sil, %sil
leaq 0x1(%rax,%rdx), %rax
cmovleq %r10, %rax
shrq %cl, %r9
andq %rax, %r9
orq %r8, %r9
movq %r9, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash_helper.c
// Function: geohashEstimateStepsByRadius
uint8_t geohashEstimateStepsByRadius(double range_meters, double lat) {
    if (range_meters == 0) return 26;
    int step = 1;
    while (range_meters < MERCATOR_MAX) {
        range_meters *= 2;
        step++;
    }
    step -= 2; /* Make sure range is included in most of the base cases. */

    /* Wider range torwards the poles... Note: it is possible to do better
     * than this approximation by computing the distance between meridians
     * at this latitude, but this does the trick for now. */
    if (lat > 66 || lat < -66) {
        step--;
        if (lat > 80 || lat < -80) step--;
    }

    /* Frame to valid range. */
    if (step < 1) step = 1;
    if (step > 26) step = 26;
    return step;
}

// Assembly:
movb $0x1a, %al
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x8e367
jp 0x8e367
retq
pushq $-0x3
popq %rax
movsd 0x34dfe(%rip), %xmm2    # 0xc3170
ucomisd %xmm0, %xmm2
jbe 0x8e380
addsd %xmm0, %xmm0
incl %eax
jmp 0x8e372
andpd 0x31de8(%rip), %xmm1    # 0xc0170
ucomisd 0x34de8(%rip), %xmm1    # 0xc3178
jbe 0x8e3a0
ucomisd 0x34de6(%rip), %xmm1    # 0xc3180
ja 0x8e3a3
incl %eax
jmp 0x8e3a3
addl $0x2, %eax
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
cmpl $0x1a, %ecx
pushq $0x1a
popq %rax
cmovll %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash_helper.c
// Function: geohashBoundingBox
int geohashBoundingBox(double longitude, double latitude, double radius_meters,
                       double *bounds) {
    if (!bounds) return 0;

    bounds[0] = longitude - rad_deg(radius_meters/EARTH_RADIUS_IN_METERS/cos(deg_rad(latitude)));
    bounds[2] = longitude + rad_deg(radius_meters/EARTH_RADIUS_IN_METERS/cos(deg_rad(latitude)));
    bounds[1] = latitude - rad_deg(radius_meters/EARTH_RADIUS_IN_METERS);
    bounds[3] = latitude + rad_deg(radius_meters/EARTH_RADIUS_IN_METERS);
    return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x8e478
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movapd %xmm1, %xmm3
mulsd 0x339e5(%rip), %xmm3    # 0xc1db8
movapd %xmm3, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movapd %xmm3, %xmm0
movaps %xmm2, (%rsp)
movapd %xmm1, 0x30(%rsp)
callq 0x263d0
movapd (%rsp), %xmm1
divsd 0x34d8a(%rip), %xmm1    # 0xc3188
movapd %xmm1, (%rsp)
divsd %xmm0, %xmm1
divsd 0x339a9(%rip), %xmm1    # 0xc1db8
movapd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movapd 0x20(%rsp), %xmm0
callq 0x263d0
movapd (%rsp), %xmm2
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
divpd 0x34d5f(%rip), %xmm2    # 0xc31a0
movapd 0x30(%rsp), %xmm3
movapd %xmm3, %xmm0
unpcklpd 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movapd %xmm3, %xmm1
subpd %xmm2, %xmm1
addpd %xmm2, %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
movupd %xmm0, 0x8(%rbx)
addsd %xmm3, %xmm2
movsd %xmm2, 0x18(%rbx)
pushq $0x1
popq %rax
addq $0x40, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/geohash-int/geohash_helper.c
// Function: geohashGetDistance
double geohashGetDistance(double lon1d, double lat1d, double lon2d, double lat2d) {
    double lat1r, lon1r, lat2r, lon2r, u, v;
    lat1r = deg_rad(lat1d);
    lon1r = deg_rad(lon1d);
    lat2r = deg_rad(lat2d);
    lon2r = deg_rad(lon2d);
    u = sin((lat2r - lat1r) / 2);
    v = sin((lon2r - lon1r) / 2);
    return 2.0 * EARTH_RADIUS_IN_METERS *
           asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v));
}

// Assembly:
subq $0x28, %rsp
movsd 0x334ea(%rip), %xmm4    # 0xc1db8
mulsd %xmm4, %xmm1
movsd %xmm1, 0x10(%rsp)
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm3
movsd %xmm3, 0x18(%rsp)
mulsd %xmm2, %xmm4
subsd %xmm0, %xmm4
movsd %xmm4, 0x8(%rsp)
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
mulsd 0x34764(%rip), %xmm0    # 0xc3068
callq 0x26c90
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x3474b(%rip), %xmm0    # 0xc3068
callq 0x26c90
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x263d0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x263d0
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x8e97a
sqrtsd %xmm0, %xmm0
jmp 0x8e97f
callq 0x26c10
callq 0x265a0
mulsd 0x34804(%rip), %xmm0    # 0xc3190
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_reset
void bind_reset(void) {
	// unbind _all_ controls
	while (controls) {
		struct bind *b = controls->data;
		controls = list_delete(controls, b);
		free(b);
	}

	// then rebind what's configured
	for (int i = 0; i < NUM_CONTROL_BUILTINS; i++) {
		bind_control(control_builtins[i].ctl, control_builtins[i].func);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xae59(%rip), %rdi      # 0xf700
testq %rdi, %rdi
je 0x48c9
movq 0x8(%rdi), %rbx
movq %rbx, %rsi
callq 0x824d
movq %rax, 0xae41(%rip)      # 0xf700
movq %rbx, %rdi
callq 0x42d0
jmp 0x48a0
pushq $0x8
popq %rbx
leaq 0xa03d(%rip), %r14      # 0xe910
cmpq $0x268, %rbx            # imm = 0x268
je 0x48f0
movq -0x8(%rbx,%r14), %rdi
movq (%rbx,%r14), %rsi
callq 0x48f8
addq $0x10, %rbx
jmp 0x48d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_modifier
void bind_modifier(const char *modname, const char *modstr) {
	if (!modstr)
		return;
	struct name_to_modifier *destm = modifier_by_name(modname);
	if (!destm)
		return;
	destm->value = 0;

	// parse modstr
	char *moddup = xstrdup(modstr);
	for (char *tmp = strtok(moddup, ",+"); tmp; tmp = strtok(NULL, ",+")) {
		// is this a modifier?
		struct name_to_modifier *m = modifier_by_name(tmp);
		if (m) {
			destm->value |= m->value;
			continue;
		}
	}
	free(moddup);
	if (!strcmp(modname, "altmask"))
		altmask = destm->value;
}

// Assembly:
testq %rsi, %rsi
je 0x4c10
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x4c11
testq %rax, %rax
je 0x4c05
movq %rax, %rbx
andl $0x0, 0x8(%rax)
movq %r15, %rdi
callq 0x9a48
movq %rax, %r15
leaq 0x54af(%rip), %r12      # 0xa064
movq %rax, %rdi
movq %r12, %rsi
callq 0x4580
testq %rax, %rax
je 0x4be1
movq %rax, %rdi
callq 0x4c11
movl $0x0, %edi
testq %rax, %rax
je 0x4bb8
movl 0x8(%rax), %eax
orl %eax, 0x8(%rbx)
xorl %edi, %edi
jmp 0x4bb8
movq %r15, %rdi
callq 0x42d0
leaq 0x543c(%rip), %rsi      # 0xa02c
movq %r14, %rdi
callq 0x4540
testl %eax, %eax
jne 0x4c05
movl 0x8(%rbx), %eax
movl %eax, 0xa803(%rip)      # 0xf408
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: modifier_by_name
static struct name_to_modifier *modifier_by_name(const char *name) {
	for (int i = 0; i < NUM_NAME_TO_MODIFIER; i++) {
		if (!strcmp(name_to_modifier[i].name, name)) {
			return &name_to_modifier[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0xa7bb(%rip), %r15      # 0xf3e0
xorl %ecx, %ecx
leaq 0x10(%rcx), %r12
cmpq $0xd0, %r12
je 0x4c4f
movq (%rcx,%r15), %rdi
movq %r14, %rsi
callq 0x4540
movq %r12, %rcx
testl %eax, %eax
jne 0x4c27
leaq (%r12,%r15), %rbx
addq $-0x10, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_grab_for_screen
void bind_grab_for_screen(struct screen *s) {
	// Release any previous grabs
	XUngrabKey(display.dpy, AnyKey, AnyModifier, s->root);

	for (struct list *l = controls; l; l = l->next) {
		struct bind *b = l->data;
		if (b->type == KeyPress) {
			grab_keysym(b->control.key, b->state, s->root);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rax
leaq 0xaab2(%rip), %r13      # 0xf728
movq (%r13), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x4240
leaq 0xaa6a(%rip), %rbx      # 0xf700
pushq $0x1
popq %rbp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4d5b
movq 0x8(%rbx), %rax
cmpl $0x2, (%rax)
jne 0x4c99
movq 0x8(%rax), %rsi
movl 0x10(%rax), %r15d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r14
movq (%r13), %rdi
callq 0x4610
movq (%r13), %rdi
movzbl %al, %r12d
movl %ebp, (%rsp)
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x4660
movq (%r13), %rdi
movl %r15d, %edx
orl $0x2, %edx
movl %ebp, (%rsp)
movl %r12d, %esi
movq %r14, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x4660
leaq 0xabcc(%rip), %rax      # 0xf8d8
movl (%rax), %edx
testl %edx, %edx
je 0x4c99
movq (%r13), %rdi
orl %r15d, %edx
movl %ebp, (%rsp)
movl %r12d, %esi
movq %r14, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x4660
movq (%r13), %rdi
leaq 0xaba0(%rip), %rax      # 0xf8d8
orl (%rax), %r15d
orl $0x2, %r15d
movl %ebp, (%rsp)
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x4660
jmp 0x4c99
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_grab_for_client
void bind_grab_for_client(struct client *c) {
	// Button binds way less configurable than key binds for now.
	// Modifiers in the bind are ignored, and we ONLY use 'mask2' and
	// 'mask2+altmask'.

	for (struct list *l = controls; l; l = l->next) {
		struct bind *b = l->data;
		if (b->type == ButtonPress) {
			grab_button(b->control.button, grabmask2, c->parent);
			grab_button(b->control.button, grabmask2|altmask, c->parent);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa987(%rip), %r14      # 0xf700
movq (%r14), %r14
testq %r14, %r14
je 0x4db9
movq 0x8(%r14), %r15
cmpl $0x4, (%r15)
jne 0x4d79
movl 0x8(%r15), %edi
movl 0xa663(%rip), %esi      # 0xf3f8
movq 0x8(%rbx), %rdx
callq 0x4dbf
movl 0x8(%r15), %edi
movl 0xa660(%rip), %esi      # 0xf408
orl 0xa64a(%rip), %esi      # 0xf3f8
movq 0x8(%rbx), %rdx
callq 0x4dbf
jmp 0x4d79
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: grab_button
static void grab_button(unsigned button, unsigned modifiers, Window w) {
	XGrabButton(display.dpy, button, modifiers, w,
		    False, ButtonPressMask | ButtonReleaseMask,
		    GrabModeAsync, GrabModeSync, None, None);
	XGrabButton(display.dpy, button, modifiers|LockMask, w,
		    False, ButtonPressMask | ButtonReleaseMask,
		    GrabModeAsync, GrabModeSync, None, None);
	if (numlockmask) {
		XGrabButton(display.dpy, button, modifiers|numlockmask, w,
			    False, ButtonPressMask | ButtonReleaseMask,
			    GrabModeAsync, GrabModeSync, None, None);
		XGrabButton(display.dpy, button, modifiers|numlockmask|LockMask, w,
			    False, ButtonPressMask | ButtonReleaseMask,
			    GrabModeAsync, GrabModeSync, None, None);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
leaq 0xa94c(%rip), %r13      # 0xf728
movq (%r13), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
pushq $0x1
popq %r12
andl $0x0, 0x8(%rsp)
movl %r12d, (%rsp)
pushq $0xc
popq %r15
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
movl %r15d, %r9d
callq 0x4620
movq (%r13), %rdi
movl %ebp, %edx
orl $0x2, %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl %r12d, (%rsp)
movl %r14d, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
movl %r15d, %r9d
callq 0x4620
leaq 0xaa9a(%rip), %r15      # 0xf8d8
movl (%r15), %edx
testl %edx, %edx
je 0x4e9d
movq (%r13), %rdi
orl %ebp, %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl %r12d, (%rsp)
pushq $0xc
popq %r9
movl %r14d, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x4620
movq (%r13), %rdi
orl (%r15), %ebp
orl $0x2, %ebp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl %r12d, (%rsp)
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
pushq $0xc
popq %r9
callq 0x4620
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_handle_key
void bind_handle_key(XKeyEvent *e) {
	KeySym key = XkbKeycodeToKeysym(display.dpy, e->keycode, 0, 0);

	for (struct list *l = controls; l; l = l->next) {
		struct bind *bind = l->data;
		if (bind->type == KeyPress && key == bind->control.key && (e->state & KEY_STATE_MASK & ~numlockmask) == (bind->state & ~numlockmask)) {
			void *sptr = NULL;
			if (bind->flags & FL_CLIENT) {
				sptr = current;
				if (!sptr)
					return;
			} else if (bind->flags & FL_SCREEN) {
				sptr = find_current_screen();
				if (!sptr)
					return;
			}
			bind->func(sptr, (XEvent *)e, bind->flags);
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa86e(%rip), %rax      # 0xf728
movq (%rax), %rdi
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4260
leaq 0xaa07(%rip), %rcx      # 0xf8d8
movl (%rcx), %ecx
notl %ecx
leaq 0xa824(%rip), %rdx      # 0xf700
movl $0xfd, %esi
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4f4b
movq 0x8(%rdx), %r14
cmpl $0x2, (%r14)
jne 0x4ee1
cmpq 0x8(%r14), %rax
jne 0x4ee1
movl 0x50(%rbx), %edi
andl %esi, %edi
xorl 0x10(%r14), %edi
testl %ecx, %edi
jne 0x4ee1
movl 0x20(%r14), %edx
btl $0x10, %edx
jb 0x4f19
testw %dx, %dx
js 0x4f2a
xorl %edi, %edi
jmp 0x4f3b
leaq 0xa800(%rip), %rax      # 0xf720
movq (%rax), %rdi
testq %rdi, %rdi
jne 0x4f3b
jmp 0x4f4b
callq 0x910f
testq %rax, %rax
je 0x4f4b
movq %rax, %rdi
movl 0x20(%r14), %edx
movq 0x18(%r14), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/bind.c
// Function: bind_handle_button
void bind_handle_button(XButtonEvent *e) {
	for (struct list *l = controls; l; l = l->next) {
		struct bind *bind = l->data;
		if (bind->type == ButtonPress && e->button == bind->control.button && (e->state & BUTTON_STATE_MASK & ~numlockmask) == (bind->state & ~numlockmask)) {
			void *sptr = NULL;
			if (bind->flags & FL_CLIENT) {
				sptr = find_client(e->window);
			} else if (bind->flags & FL_SCREEN) {
				sptr = find_current_screen();
			}
			if (!sptr)
				return;
			bind->func(sptr, (XEvent *)e, bind->flags);
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xa498(%rip), %eax      # 0xf3f8
notl %eax
andl $0xfd, %eax
leaq 0xa96a(%rip), %rcx      # 0xf8d8
movl (%rcx), %ecx
notl %ecx
leaq 0xa787(%rip), %rdx      # 0xf700
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4fdc
movq 0x8(%rdx), %r14
cmpl $0x4, (%r14)
jne 0x4f79
movl 0x54(%rbx), %esi
cmpl 0x8(%r14), %esi
jne 0x4f79
movl 0x50(%rbx), %esi
andl %eax, %esi
xorl 0x10(%r14), %esi
testl %ecx, %esi
jne 0x4f79
movl 0x20(%r14), %eax
btl $0x10, %eax
jb 0x4fb7
testw %ax, %ax
jns 0x4fdc
callq 0x910f
jmp 0x4fc0
movq 0x20(%rbx), %rdi
callq 0x50fc
testq %rax, %rax
je 0x4fdc
movq 0x18(%r14), %rcx
movl 0x20(%r14), %edx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: get_wm_normal_hints
long get_wm_normal_hints(struct client *c) {
	long flags;
	long dummy;
	XSizeHints *size = XAllocSizeHints();

	LOG_XENTER("XGetWMNormalHints(window=%lx)", (unsigned long)c->window);
	XGetWMNormalHints(display.dpy, c->window, size, &dummy);
	debug_wm_normal_hints(size);
	LOG_XLEAVE();

	flags = size->flags;

	if (flags & PMinSize) {
		c->min_width = size->min_width;
		c->min_height = size->min_height;
	} else {
		c->min_width = c->min_height = 0;
	}

	if (flags & PMaxSize) {
		c->max_width = size->max_width;
		c->max_height = size->max_height;
	} else {
		c->max_width = c->max_height = 0;
	}

	if (flags & PBaseSize) {
		c->base_width = size->base_width;
		c->base_height = size->base_height;
	} else {
		c->base_width = c->min_width;
		c->base_height = c->min_height;
	}

	c->width_inc = c->height_inc = 1;
	if (flags & PResizeInc) {
		c->width_inc = size->width_inc ? size->width_inc : 1;
		c->height_inc = size->height_inc ? size->height_inc : 1;
	}

	if (!(flags & PMinSize)) {
		c->min_width = c->base_width + c->width_inc;
		c->min_height = c->base_height + c->height_inc;
	}

	if (flags & PWinGravity) {
		c->win_gravity_hint = size->win_gravity;
	} else {
		c->win_gravity_hint = NorthWestGravity;
	}
	c->win_gravity = c->win_gravity_hint;

	XFree(size);
	return flags;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4650
movq %rax, %r14
leaq 0xa729(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq (%rbx), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdx
callq 0x4120
movq (%r14), %r15
xorl %eax, %eax
movl $0x0, %ecx
testb $0x10, %r15b
je 0x502a
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %eax
movl %eax, 0x70(%rbx)
movl %ecx, 0x6c(%rbx)
xorps %xmm0, %xmm0
testb $0x20, %r15b
je 0x503f
movsd 0x20(%r14), %xmm0
movlps %xmm0, 0x74(%rbx)
btl $0x8, %r15d
jae 0x5052
movl 0x40(%r14), %ecx
movl 0x44(%r14), %eax
movl %ecx, 0x84(%rbx)
movl %eax, 0x88(%rbx)
movabsq $0x100000001, %rdx      # imm = 0x100000001
movq %rdx, 0x7c(%rbx)
testb $0x40, %r15b
jne 0x5079
pushq $0x1
popq %rdx
movl %edx, %esi
jmp 0x5096
movl 0x28(%r14), %esi
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x7c(%rbx)
movl 0x2c(%r14), %edx
cmpl $0x1, %edx
adcl $0x0, %edx
movl %edx, 0x80(%rbx)
testb $0x10, %r15b
jne 0x50a6
addl %ecx, %esi
movl %esi, 0x6c(%rbx)
addl %eax, %edx
movl %edx, 0x70(%rbx)
btl $0x9, %r15d
jb 0x50b2
pushq $0x1
popq %rax
jmp 0x50b6
movl 0x48(%r14), %eax
movl %eax, 0x8c(%rbx)
movl %eax, 0x90(%rbx)
movq %r14, %rdi
callq 0x4050
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: find_client
struct client *find_client(Window w) {
	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		if (w == c->parent || w == c->window)
			return c;
	}
	return NULL;
}

// Assembly:
leaq 0xa605(%rip), %rcx      # 0xf708
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x511b
movq 0x8(%rcx), %rax
cmpq %rdi, 0x8(%rax)
je 0x511a
cmpq %rdi, (%rax)
jne 0x5103
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: client_raise
void client_raise(struct client *c) {
	LOG_XDEBUG("XRaiseWindow(window=%lx,parent=%lx)\n", (unsigned long)c->window, (unsigned long)c->parent);
	XRaiseWindow(display.dpy, c->parent);
	clients_stacking_order = list_to_tail(clients_stacking_order, c);
	ewmh_set_net_client_list_stacking(c->screen);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa3bd(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x4180
movq 0xa39a(%rip), %rdi      # 0xf718
movq %rbx, %rsi
callq 0x82a0
movq %rax, 0xa38b(%rip)      # 0xf718
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x7a29
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: client_lower
void client_lower(struct client *c) {
	LOG_XDEBUG("XLowerWindow(window=%lx,parent=%lx)\n", (unsigned long)c->window, (unsigned long)c->parent);
	XLowerWindow(display.dpy, c->parent);
	clients_stacking_order = list_to_head(clients_stacking_order, c);
	ewmh_set_net_client_list_stacking(c->screen);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa386(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x43f0
movq 0xa363(%rip), %rdi      # 0xf718
movq %rbx, %rsi
callq 0x8282
movq %rax, 0xa354(%rip)      # 0xf718
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x7a29
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: send_config
void send_config(struct client *c) {
	XEvent ev = {
		.xconfigure = {
			.type = ConfigureNotify,
			.event = c->window,
			.window = c->window,
			.x = c->x,
			.y = c->y,
			.width = c->width,
			.height = c->height,
			.border_width = 0,
			.above = None,
			.override_redirect = False
		}
	};
	XSendEvent(display.dpy, c->window, False, StructureNotifyMask, &ev);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4080
movl $0x16, (%r14)
movq (%rbx), %rsi
movq %rsi, 0x20(%r14)
movq %rsi, 0x28(%r14)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x30(%r14)
leaq 0xa317(%rip), %rax      # 0xf728
movq (%rax), %rdi
movl $0x20000, %ecx          # imm = 0x20000
xorl %edx, %edx
movq %r14, %r8
callq 0x4520
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: client_gravitate
void client_gravitate(struct client *c, int bw) {
	int dx = 0, dy = 0;
	switch (c->win_gravity) {
	default:
	case NorthWestGravity:
		dx = bw;
		dy = bw;
		break;
	case NorthGravity:
		dy = bw;
		break;
	case NorthEastGravity:
		dx = -bw;
		dy = bw;
		break;
	case EastGravity:
		dx = -bw;
		break;
	case CenterGravity:
		break;
	case WestGravity:
		dx = bw;
		break;
	case SouthWestGravity:
		dx = bw;
		dy = -bw;
		break;
	case SouthGravity:
		dy = -bw;
		break;
	case SouthEastGravity:
		dx = -bw;
		dy = -bw;
		break;
	}
	// Don't gravitate if client would be maximised along either axis
	// (unless it's offset already).
	if (c->x != 0 || c->width != DisplayWidth(display.dpy, c->screen->screen)) {
		c->x += dx;
	}
	if (c->y != 0 || c->height != DisplayHeight(display.dpy, c->screen->screen)) {
		c->y += dy;
	}
}

// Assembly:
movl 0x90(%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x545c
xorl %eax, %eax
leaq 0x4fcb(%rip), %rdx      # 0xa410
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
jmp 0x546a
negl %esi
movl %esi, %eax
xorl %esi, %esi
jmp 0x546a
negl %esi
movl %esi, %eax
jmp 0x546a
movl %esi, %eax
negl %eax
jmp 0x546a
movl %esi, %eax
negl %esi
movl 0x28(%rdi), %ecx
testl %ecx, %ecx
jne 0x5497
movl 0x30(%rdi), %edx
leaq 0xa2ad(%rip), %r8       # 0xf728
movq (%r8), %r8
movq 0xe8(%r8), %r8
movq 0x10(%rdi), %r9
movslq (%r9), %r9
shlq $0x7, %r9
cmpl 0x18(%r8,%r9), %edx
je 0x549c
addl %eax, %ecx
movl %ecx, 0x28(%rdi)
movl 0x2c(%rdi), %eax
testl %eax, %eax
jne 0x54c9
movl 0x34(%rdi), %ecx
leaq 0xa27b(%rip), %rdx      # 0xf728
movq (%rdx), %rdx
movq 0xe8(%rdx), %rdx
movq 0x10(%rdi), %r8
movslq (%r8), %r8
shlq $0x7, %r8
cmpl 0x1c(%rdx,%r8), %ecx
je 0x54ce
addl %esi, %eax
movl %eax, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: select_client
void select_client(struct client *c) {
	struct client *old_current = current;
	if (current)
		XSetWindowBorder(display.dpy, current->parent, current->screen->bg.pixel);
	if (c) {
		unsigned long bpixel;
		if (is_fixed(c))
			bpixel = c->screen->fc.pixel;
		else
			bpixel = c->screen->fg.pixel;
		XSetWindowBorder(display.dpy, c->parent, bpixel);
		XInstallColormap(display.dpy, c->cmap);
		XSetInputFocus(display.dpy, c->window, RevertToPointerRoot, CurrentTime);
	}
	current = c;
	// Update _NET_WM_STATE_FOCUSED for old current and _NET_ACTIVE_WINDOW
	// on its screen root.
	if (old_current)
		ewmh_set_net_wm_state(old_current);
	// Now do same for new current.
	if (c)
		ewmh_set_net_wm_state(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa242(%rip), %r14      # 0xf720
testq %r14, %r14
je 0x54fe
leaq 0xa23e(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
movq 0x40(%rax), %rdx
callq 0x4310
testq %rbx, %rbx
je 0x5547
xorl %eax, %eax
cmpl $-0x1, 0x20(%rbx)
sete %al
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rcx
shll $0x5, %eax
movq 0x30(%rax,%rcx), %rdx
leaq 0xa205(%rip), %r15      # 0xf728
movq (%r15), %rdi
callq 0x4310
movq (%r15), %rdi
movq 0x18(%rbx), %rsi
callq 0x4590
movq (%r15), %rdi
movq (%rbx), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x44c0
movq %rbx, 0xa1d2(%rip)      # 0xf720
testq %r14, %r14
je 0x555b
movq %r14, %rdi
callq 0x7b5e
testq %rbx, %rbx
je 0x556d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7b5e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: client_to_vdesk
void client_to_vdesk(struct client *c, unsigned vdesk) {
	if (valid_vdesk(vdesk)) {
		c->vdesk = vdesk;
		if (c->vdesk == c->screen->vdesk || c->vdesk == VDESK_FIXED) {
			client_show(c);
		} else {
			client_hide(c);
		}
		ewmh_set_net_wm_desktop(c);
		select_client(current);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x558a
leaq 0xa36d(%rip), %rax      # 0xf8f0
cmpl %esi, 0x2c(%rax)
ja 0x558a
popq %rbx
retq
movl %esi, 0x20(%rbx)
cmpl $-0x1, %esi
je 0x55a5
movq 0x10(%rbx), %rax
cmpl %esi, 0x60(%rax)
je 0x55a5
movq %rbx, %rdi
callq 0x52dc
jmp 0x55ad
movq %rbx, %rdi
callq 0x533d
movq %rbx, %rdi
callq 0x7d15
movq 0xa164(%rip), %rdi      # 0xf720
popq %rbx
jmp 0x54cf
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: send_wm_delete
void send_wm_delete(struct client *c, int kill_client) {
	_Bool delete_supported = 0;
	int n;
	Atom *protocols;

	if (!kill_client && XGetWMProtocols(display.dpy, c->window, &protocols, &n)) {
		for (int i = 0; i < n; i++)
			if (protocols[i] == X_ATOM(WM_DELETE_WINDOW))
				delete_supported = 1;
		XFree(protocols);
	}
	if (delete_supported) {
		XEvent ev = {
			.xclient = {
				.type = ClientMessage,
				.window = c->window,
				.message_type = X_ATOM(WM_PROTOCOLS),
				.format = 32,
				.data.l = { X_ATOM(WM_DELETE_WINDOW), CurrentTime }
			}
		};
		XSendEvent(display.dpy, c->window, False, NoEventMask, &ev);
	} else {
		XKillClient(display.dpy, c->window);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x5756
leaq 0x9fea(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x4770
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9fcb(%rip), %r15      # 0xf728
movq (%r15), %rdi
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x46a0
testl %eax, %eax
je 0x5737
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rdi
movq 0x18(%r15), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorl %r14d, %r14d
cmpq %rdx, %rax
je 0x57a2
cmpq %rcx, (%rdi,%rdx,8)
sete %sil
orb %sil, %r14b
incq %rdx
jmp 0x578d
callq 0x4050
testb $0x1, %r14b
je 0x5737
leaq 0x10(%rsp), %r14
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4080
movl $0x21, (%r14)
movq (%rbx), %rsi
movq %rsi, 0x20(%r14)
movq (%r15), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x28(%r14)
movl $0x20, 0x30(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x4520
jmp 0x5749
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: set_shape
void set_shape(struct client *c) {
	Bool bounding_shaped;
	Bool b;  // dummy
	int i;  // dummy
	unsigned u;  // dummy

	if (!display.have_shape) return;

	// Logic to decide if we have a shaped window cribbed from fvwm-2.5.10.
	// Previous method (more than one rectangle returned from
	// XShapeGetRectangles) worked _most_ of the time.

	if (XShapeQueryExtents(display.dpy, c->window, &bounding_shaped, &i, &i,
				&u, &u, &b, &i, &i, &u, &u) && bounding_shaped) {
		LOG_DEBUG("%d shape extents\n", bounding_shaped);
		XShapeCombineShape(display.dpy, c->parent, ShapeBounding, 0, 0,
				c->window, ShapeBounding, ShapeSet);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x9f1f(%rip), %r14      # 0xf728
cmpl $0x0, 0x178(%r14)
je 0x5875
movq %rdi, %rbx
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0xc(%rsp), %r9
leaq 0x10(%rsp), %rcx
leaq 0x14(%rsp), %rax
leaq 0x8(%rsp), %rdx
movq %rcx, %r8
pushq %r9
pushq %r9
pushq %rcx
pushq %rcx
pushq %rax
pushq %r9
callq 0x43e0
addq $0x30, %rsp
testl %eax, %eax
je 0x5875
cmpl $0x0, 0x8(%rsp)
je 0x5875
movq (%r14), %rdi
movq (%rbx), %r9
movq 0x8(%rbx), %rsi
subq $0x10, %rsp
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4710
popq %rax
popq %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client.c
// Function: create_info_window
void create_info_window(struct client *c) {
        display.info_window = XCreateSimpleWindow(display.dpy, c->screen->root, -4, -4, 2, 2,
                        0, c->screen->fg.pixel, c->screen->fg.pixel);
        XMapRaised(display.dpy, display.info_window);
        update_info_window(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9e9d(%rip), %r14      # 0xf728
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rax), %rax
subq $0x8, %rsp
pushq $-0x4
popq %rcx
pushq $0x2
popq %r8
movl %ecx, %edx
movl %r8d, %r9d
pushq %rax
pushq %rax
pushq $0x0
callq 0x4270
addq $0x20, %rsp
movq %rax, 0x198(%r14)
movq (%r14), %rdi
movq %rax, %rsi
callq 0x46f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x58d8
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client_move.c
// Function: draw_outline
static void draw_outline(struct client *c) {
#ifndef INFOBANNER_MOVERESIZE
	char buf[27];
	int width_inc = c->width_inc, height_inc = c->height_inc;
#endif

	XDrawRectangle(display.dpy, c->screen->root, c->screen->invert_gc,
		c->x - c->border, c->y - c->border,
		c->width + 2*c->border-1, c->height + 2*c->border-1);

#ifndef INFOBANNER_MOVERESIZE
	snprintf(buf, sizeof(buf), "%dx%d+%d+%d", (c->width-c->base_width)/width_inc,
			(c->height-c->base_height)/height_inc, c->x, c->y);
	XDrawString(display.dpy, c->screen->root, c->screen->invert_gc,
		c->x + c->width - XTextWidth(display.font, buf, strlen(buf)) - SPACE,
		c->y + c->height - SPACE,
		buf, strlen(buf));
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x7c(%rdi), %r14d
movl 0x80(%rdi), %ebp
leaq 0x99ba(%rip), %r15      # 0xf728
movq (%r15), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rax), %rdx
movl 0x28(%rbx), %ecx
movl 0x3c(%rbx), %eax
subl %eax, %ecx
movl 0x2c(%rbx), %r8d
subl %eax, %r8d
leal -0x1(,%rax,2), %eax
movl 0x30(%rbx), %r9d
addl %eax, %r9d
addl 0x34(%rbx), %eax
movl %eax, (%rsp)
callq 0x43c0
movl 0x30(%rbx), %eax
subl 0x84(%rbx), %eax
cltd
idivl %r14d
movl %eax, %ecx
movl 0x34(%rbx), %eax
subl 0x88(%rbx), %eax
cltd
idivl %ebp
movl 0x28(%rbx), %r9d
movl 0x2c(%rbx), %edx
movl %edx, (%rsp)
leaq 0x465f(%rip), %rdx      # 0xa430
leaq 0x10(%rsp), %r14
pushq $0x1b
popq %rsi
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
callq 0x40a0
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %r12
movl 0x28(%rbx), %ebp
movq (%r15), %r13
movq 0x160(%r15), %r15
addl 0x30(%rbx), %ebp
movq %r14, %rdi
callq 0x42f0
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x44e0
subl %eax, %ebp
addl $-0x3, %ebp
movl 0x2c(%rbx), %eax
movl 0x34(%rbx), %ecx
leal (%rax,%rcx), %ebx
addl $-0x3, %ebx
movq %r14, %rdi
callq 0x42f0
movl %eax, (%rsp)
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq %r14, %r9
callq 0x4030
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client_move.c
// Function: client_show_info
void client_show_info(struct client *c, XEvent *e) {
	unsigned input;

	if (e->type == KeyPress) {
		input = e->xkey.keycode;
		if (XGrabKeyboard(display.dpy, c->screen->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess)
			return;
	} else {
		input = e->xbutton.button;
		if (!grab_pointer(c->screen->root, None))
			return;
	}

#ifdef INFOBANNER
	create_info_window(c);
#else
	XGrabServer(display.dpy);
	draw_outline(c);
#endif

	for (;;) {
		XEvent ev;
		if (e->type == KeyPress) {
			XMaskEvent(display.dpy, KeyReleaseMask, &ev);
			if (ev.xkey.keycode != input)
				continue;
			if (XCheckIfEvent(display.dpy, &ev, predicate_keyrepeatpress, (XPointer)&ev)) {
				// Autorepeat keypress detected - ignore!
				continue;
			}
		} else {
			XMaskEvent(display.dpy, ButtonReleaseMask, &ev);
			if (ev.xbutton.button != input)
				continue;
		}
		break;
	}

#ifdef INFOBANNER
	remove_info_window();
#else
	draw_outline(c);
	XUngrabServer(display.dpy);
#endif

	if (e->type == KeyPress) {
		XUngrabKeyboard(display.dpy, CurrentTime);
	} else {
		XUngrabPointer(display.dpy, CurrentTime);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rsi), %r12d
cmpl $0x2, (%rsi)
leaq 0x9394(%rip), %rbp      # 0xf728
movq (%rbp), %rdi
movq 0x10(%r14), %rax
movq 0x10(%rax), %rsi
jne 0x63b4
pushq $0x1
popq %rcx
xorl %edx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x45e0
jmp 0x63d2
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x4c
popq %rcx
pushq $0x1
popq %r8
xorl %edx, %edx
movl %r8d, %r9d
callq 0x4220
testl %eax, %eax
jne 0x6452
movq %r14, %rdi
callq 0x587d
pushq $0x2
popq %r14
leaq 0x18(%rsp), %r15
pushq $0x8
popq %r13
cmpl $0x2, (%rbx)
movq (%rbp), %rdi
jne 0x6422
movq %r14, %rsi
movq %r15, %rdx
callq 0x4510
cmpl %r12d, 0x6c(%rsp)
jne 0x63eb
movq (%rbp), %rdi
movq %r15, %rsi
leaq 0x50(%rip), %rdx        # 0x6464
movq %r15, %rcx
callq 0x4550
testl %eax, %eax
jne 0x63eb
jmp 0x6434
movq %r13, %rsi
movq %r15, %rdx
callq 0x4510
cmpl %r12d, 0x6c(%rsp)
jne 0x63eb
callq 0x5ae5
cmpl $0x2, (%rbx)
movq (%rbp), %rdi
jne 0x644b
xorl %esi, %esi
callq 0x4450
jmp 0x6452
xorl %esi, %esi
callq 0x41b0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client_move.c
// Function: predicate_keyrepeatpress
static Bool predicate_keyrepeatpress(Display *dummy, XEvent *ev, XPointer arg) {
	(void)dummy;
	XEvent *release_event = (XEvent *)arg;
	if (ev->type != KeyPress)
		return False;
	if (release_event->xkey.keycode != ev->xkey.keycode)
		return False;
	return release_event->xkey.time == ev->xkey.time;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, (%rsi)
jne 0x6480
movl 0x54(%rdx), %ecx
cmpl 0x54(%rsi), %ecx
jne 0x6480
movq 0x38(%rdx), %rcx
xorl %eax, %eax
cmpq 0x38(%rsi), %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client_move.c
// Function: client_moveresize
void client_moveresize(struct client *c) {
	XMoveResizeWindow(display.dpy, c->parent, c->x - c->border, c->y - c->border,
			c->width, c->height);
	XMoveResizeWindow(display.dpy, c->window, 0, 0, c->width, c->height);
	send_config(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9299(%rip), %r14      # 0xf728
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movl 0x3c(%rbx), %eax
subl %eax, %edx
movl 0x2c(%rbx), %ecx
subl %eax, %ecx
movl 0x30(%rbx), %r8d
movl 0x34(%rbx), %r9d
callq 0x43b0
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x30(%rbx), %r8d
movl 0x34(%rbx), %r9d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53ce
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/client_move.c
// Function: client_select_next
void client_select_next(void) {
	struct list *newl = list_find(clients_tab_order, current);
	struct client *newc;

	do {
		if (newl) {
			newl = newl->next;
			if (!newl && !current)
				return;
		}
		if (!newl)
			newl = clients_tab_order;
		if (!newl)
			return;
		newc = newl->data;
		if (newc == current)
			return;
	} while ((!is_fixed(newc) && (newc->vdesk != newc->screen->vdesk))
		 || (newc->is_dock && !newc->screen->docks_visible));

	if (!newc)
		return;

	client_show(newc);  // XXX why would it be hidden?
	client_raise(newc);
	select_client(newc);

	// Optionally force the pointer to jump to the newly-selected window.
	// I think this was the default behaviour in much earlier versions of
	// evilwm (possibly to generate the enter event and handle selecting
	// the client as a result of that), but I don't like it now.

#ifdef WARP_POINTER
	setmouse(newc->window, newc->width + newc->border - 1,
			newc->height + newc->border - 1);
#endif

	discard_enter_events(newc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x9037(%rip), %rbx      # 0xf708
movq (%rbx), %rdi
leaq 0x9045(%rip), %r14      # 0xf720
movq (%r14), %rsi
callq 0x82be
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
je 0x66fb
movq (%rax), %rax
movq %rax, %rsi
orq %rcx, %rsi
jne 0x66fd
jmp 0x675d
xorl %eax, %eax
testq %rax, %rax
cmoveq %rdx, %rax
testq %rax, %rax
je 0x675d
movq 0x8(%rax), %rbx
cmpq %rcx, %rbx
je 0x675d
movl 0x20(%rbx), %esi
cmpl $-0x1, %esi
je 0x6723
movq 0x10(%rbx), %rdi
cmpl 0x60(%rdi), %esi
jne 0x66e9
cmpl $0x0, 0x94(%rbx)
je 0x6736
movq 0x10(%rbx), %rsi
cmpl $0x0, 0x68(%rsi)
je 0x66e9
movq %rbx, %rdi
callq 0x533d
movq %rbx, %rdi
callq 0x5360
movq %rbx, %rdi
callq 0x54cf
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9438
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/display.c
// Function: display_close
void display_close(void) {
	XSetInputFocus(display.dpy, PointerRoot, RevertToPointerRoot, CurrentTime);

	if (display.font)
		XFreeFont(display.dpy, display.font);

	for (int i = 0; i < display.nscreens; i++) {
		screen_deinit(&display.screens[i]);
		XFreeGC(display.dpy, display.screens[i].invert_gc);
		XInstallColormap(display.dpy, DefaultColormap(display.dpy, i));
		free(display.screens[i].display);
	}

	free(display.screens);

	XCloseDisplay(display.dpy);
	display.dpy = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8753(%rip), %rdi      # 0xf728
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x44c0
movq 0x889f(%rip), %rsi      # 0xf888
testq %rsi, %rsi
je 0x6ffa
movq 0x8733(%rip), %rdi      # 0xf728
callq 0x4170
pushq $0x50
popq %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x88a6(%rip), %rax      # 0xf8b0
movq 0x88a7(%rip), %rdi      # 0xf8b8
cmpq %rax, %r15
jge 0x706b
addq %r14, %rdi
callq 0x8d76
movq 0x8703(%rip), %rdi      # 0xf728
movq 0x888c(%rip), %rax      # 0xf8b8
movq 0x28(%rax,%r14), %rsi
callq 0x4390
movq 0x86eb(%rip), %rdi      # 0xf728
movq 0xe8(%rdi), %rax
movq (%rax,%rbx), %rsi
callq 0x4590
movq 0x8864(%rip), %rax      # 0xf8b8
movq 0x8(%rax,%r14), %rdi
callq 0x42d0
incq %r15
addq $0x78, %r14
subq $-0x80, %rbx
jmp 0x7003
callq 0x42d0
movq 0x86b1(%rip), %rdi      # 0xf728
callq 0x4330
andq $0x0, 0x86a4(%rip)      # 0xf728
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/display.c
// Function: display_manage_clients
void display_manage_clients(void) {
	for (int i = 0; i < display.nscreens; i++) {
		struct screen *s = &display.screens[i];

		LOG_XENTER("XQueryTree(screen=%d)", i);
		unsigned nwins;
		Window dw1, dw2, *wins;
		XQueryTree(display.dpy, s->root, &dw1, &dw2, &wins, &nwins);
		LOG_XDEBUG("%u windows\n", nwins);
		LOG_XLEAVE();

		// Manage all relevant windows
		for (unsigned j = 0; j < nwins; j++) {
			XWindowAttributes winattr;
			XGetWindowAttributes(display.dpy, wins[j], &winattr);
			// Override redirect implies a pop-up that we should ignore.
			// If map_state is not IsViewable, it shouldn't be shown right
			// now, so don't try to manage it.
			if (!winattr.override_redirect && winattr.map_state == IsViewable)
				client_manage_new(wins[j], s);
		}
		XFree(wins);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
xorl %ebx, %ebx
movq %rsp, %r15
leaq 0xc(%rsp), %r12
leaq 0x20(%rsp), %r13
movslq 0x87ff(%rip), %rax      # 0xf8b0
cmpq %rax, %rbx
jge 0x7144
movq 0x87f7(%rip), %rax      # 0xf8b8
imulq $0x78, %rbx, %rcx
leaq (%rax,%rcx), %rbp
movq 0x8658(%rip), %rdi      # 0xf728
movq 0x10(%rax,%rcx), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x4730
xorl %r14d, %r14d
movl 0xc(%rsp), %eax
cmpq %rax, %r14
jae 0x7133
movq 0x862b(%rip), %rdi      # 0xf728
movq (%rsp), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdx
callq 0x4630
cmpl $0x0, 0x98(%rsp)
jne 0x712e
cmpl $0x2, 0x7c(%rsp)
jne 0x712e
movq (%rsp), %rax
movq (%rax,%r14,8), %rdi
movq %rbp, %rsi
callq 0x6768
incq %r14
jmp 0x70ed
movq (%rsp), %rdi
callq 0x4050
incq %rbx
jmp 0x70aa
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_screen_workarea
void ewmh_set_screen_workarea(struct screen *s) {
	unsigned long workarea[4] = {
		0, 0,
		DisplayWidth(display.dpy, s->screen), DisplayHeight(display.dpy, s->screen)
	};
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_GEOMETRY),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea[2], 2);
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_VIEWPORT),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea[0], 2);
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_WORKAREA),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea, 4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rax)
leaq 0x7e30(%rip), %r15      # 0xf728
movq (%r15), %rdi
movq 0x60(%r15), %rdx
movq 0xe8(%rdi), %rcx
movslq (%rbx), %rsi
shlq $0x7, %rsi
movslq 0x18(%rcx,%rsi), %r8
movq %r8, (%rax)
movslq 0x1c(%rcx,%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rsi
pushq $0x2
popq %r12
pushq $0x6
popq %r14
pushq $0x20
popq %rbp
movq %r14, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %rax
callq 0x4640
popq %rcx
popq %rdx
movq 0x10(%rbx), %rsi
movq (%r15), %rdi
movq 0x68(%r15), %rdx
movq %rsp, %r13
movq %r14, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %r13
callq 0x4640
popq %rcx
popq %rdx
movq 0x10(%rbx), %rsi
movq (%r15), %rdi
movq 0x80(%r15), %rdx
movq %r14, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq $0x4
pushq %r13
callq 0x4640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq