LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/strbuf.c
// Function: strbuf_append_fmt_retry
void strbuf_append_fmt_retry(strbuf_t *s, const char *fmt, ...)
{
    va_list arg;
    int fmt_len, try;
    int empty_len;

    /* If the first attempt to append fails, resize the buffer appropriately
     * and try again */
    for (try = 0; ; try++) {
        va_start(arg, fmt);
        /* Append the new formatted string */
        /* fmt_len is the length of the string required, excluding the
         * trailing NULL */
        empty_len = strbuf_empty_length(s);
        /* Add 1 since there is also space to store the terminating NULL. */
        fmt_len = vsnprintf(s->buf + s->length, empty_len + 1, fmt, arg);
        va_end(arg);

        if (fmt_len <= empty_len)
            break;  /* SUCCESS */
        if (try > 0)
            die("BUG: length of formatted string changed");

        strbuf_resize(s, s->length + fmt_len);
    }

    s->length += fmt_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xd303b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
callq 0xd2eb0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rdi
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x26810
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jg 0xd30cf
jmp 0xd3104
cmpl $0x0, -0x38(%rbp)
jle 0xd30e3
leaq 0x79587(%rip), %rdi     # 0x14c663
movb $0x0, %al
callq 0xd2a40
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
addl -0x34(%rbp), %esi
callq 0xd2cb0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xd3066
movl -0x34(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0xc(%rax)
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: fpconv_strtod
double fpconv_strtod(const char *nptr, char **endptr)
{
    char localbuf[FPCONV_G_FMT_BUFSIZE];
    char *buf, *endbuf, *dp;
    int buflen;
    double value;

    /* System strtod() is fine when decimal point is '.' */
    if (locale_decimal_point == '.')
        return strtod(nptr, endptr);

    buflen = strtod_buffer_size(nptr);
    if (!buflen) {
        /* No valid characters found, standard strtod() return */
        *endptr = (char *)nptr;
        return 0;
    }

    /* Duplicate number into buffer */
    if (buflen >= FPCONV_G_FMT_BUFSIZE) {
        /* Handle unusually large numbers */
        buf = malloc(buflen + 1);
        if (!buf) {
            fprintf(stderr, "Out of memory");
            abort();
        }
    } else {
        /* This is the common case.. */
        buf = localbuf;
    }
    memcpy(buf, nptr, buflen);
    buf[buflen] = 0;

    /* Update decimal point character if found */
    dp = strchr(buf, '.');
    if (dp)
        *dp = locale_decimal_point;

    value = strtod(buf, &endbuf);
    *endptr = (char *)&nptr[endbuf - buf];
    if (buflen >= FPCONV_G_FMT_BUFSIZE)
        free(buf);

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsbl 0xa4ff9(%rip), %eax     # 0x178130
cmpl $0x2e, %eax
jne 0xd3153
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26cd0
movsd %xmm0, -0x8(%rbp)
jmp 0xd3249
movq -0x10(%rbp), %rdi
callq 0xd3260
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jne 0xd317d
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xd3249
cmpl $0x20, -0x5c(%rbp)
jl 0xd31bb
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x26360
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xd31b9
movq 0x9fe45(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
leaq 0x76a29(%rip), %rsi     # 0x149bd6
movb $0x0, %al
callq 0x26ba0
callq 0x261c0
jmp 0xd31c3
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x5c(%rbp), %rdx
callq 0x26c60
movq -0x48(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x48(%rbp), %rdi
movl $0x2e, %esi
callq 0x267f0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0xd3205
movb 0xa4f31(%rip), %cl      # 0x178130
movq -0x58(%rbp), %rax
movb %cl, (%rax)
movq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x26cd0
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x20, -0x5c(%rbp)
jl 0xd323f
movq -0x48(%rbp), %rdi
callq 0x264c0
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: strtod_buffer_size
static int strtod_buffer_size(const char *s)
{
    const char *p = s;

    while (valid_number_character(*p))
        p++;

    return p - s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0xd3470
cmpl $0x0, %eax
je 0xd3293
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd3274
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: fpconv_g_fmt
int fpconv_g_fmt(char *str, double num, int precision)
{
    char buf[FPCONV_G_FMT_BUFSIZE];
    char fmt[6];
    int len;
    char *b;

    set_number_format(fmt, precision);

    /* Pass through when decimal point character is dot. */
    if (locale_decimal_point == '.')
        return snprintf(str, FPCONV_G_FMT_BUFSIZE, fmt, num);

    /* snprintf() to a buffer then translate for other decimal point characters */
    len = snprintf(buf, FPCONV_G_FMT_BUFSIZE, fmt, num);

    /* Copy into target location. Translate decimal point if required */
    b = buf;
    do {
        *str++ = (*b == locale_decimal_point ? '.' : *b);
    } while(*b++);

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
leaq -0x46(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xd3380
movsbl 0xa4e59(%rip), %eax     # 0x178130
cmpl $0x2e, %eax
jne 0xd32fa
movq -0x10(%rbp), %rdi
leaq -0x46(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
movl $0x20, %esi
movb $0x1, %al
callq 0x26120
movl %eax, -0x4(%rbp)
jmp 0xd3374
leaq -0x40(%rbp), %rdi
leaq -0x46(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
movl $0x20, %esi
movb $0x1, %al
callq 0x26120
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xa4e04(%rip), %ecx     # 0x178130
cmpl %ecx, %eax
jne 0xd333a
movl $0x2e, %eax
movl %eax, -0x5c(%rbp)
jmp 0xd3344
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x58(%rbp)
cmpb $0x0, (%rax)
jne 0xd331e
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: set_number_format
static void set_number_format(char *fmt, int precision)
{
    int d1, d2, i;

    assert(1 <= precision && precision <= 14);

    /* Create printf format (%.14g) from precision */
    d1 = precision / 10;
    d2 = precision % 10;
    fmt[0] = '%';
    fmt[1] = '.';
    i = 2;
    if (d1) {
        fmt[i++] = '0' + d1;
    }
    fmt[i++] = '0' + d2;
    fmt[i++] = 'g';
    fmt[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jg 0xd33a1
cmpl $0xe, -0xc(%rbp)
jg 0xd33a1
jmp 0xd33c0
leaq 0x79340(%rip), %rdi     # 0x14c6e8
leaq 0x7935b(%rip), %rsi     # 0x14c70a
movl $0x9d, %edx
leaq 0x79358(%rip), %rcx     # 0x14c713
callq 0x262e0
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x25, (%rax)
movq -0x8(%rbp), %rax
movb $0x2e, 0x1(%rax)
movl $0x2, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xd3415
movl -0x10(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x67, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: valid_number_character
static inline int valid_number_character(char ch)
{
    char lower_ch;

    if ('0' <= ch && ch <= '9')
        return 1;
    if (ch == '-' || ch == '+' || ch == '.')
        return 1;

    /* Hex digits, exponent (e), base (p), "infinity",.. */
    lower_ch = ch | 0x20;
    if ('a' <= lower_ch && lower_ch <= 'y')
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0xd3499
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0xd3499
movl $0x1, -0x4(%rbp)
jmp 0xd34ed
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
je 0xd34b4
movsbl -0x5(%rbp), %eax
cmpl $0x2b, %eax
je 0xd34b4
movsbl -0x5(%rbp), %eax
cmpl $0x2e, %eax
jne 0xd34bd
movl $0x1, -0x4(%rbp)
jmp 0xd34ed
movsbl -0x5(%rbp), %eax
orl $0x20, %eax
movb %al, -0x6(%rbp)
movsbl -0x6(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xd34e6
movsbl -0x6(%rbp), %eax
cmpl $0x79, %eax
jg 0xd34e6
movl $0x1, -0x4(%rbp)
jmp 0xd34ed
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: fpconv_update_locale
static void fpconv_update_locale()
{
    char buf[8];

    snprintf(buf, sizeof(buf), "%g", 0.5);

    /* Failing this test might imply the platform has a buggy dtoa
     * implementation or wide characters */
    if (buf[0] != '0' || buf[2] != '5' || buf[3] != 0) {
        fprintf(stderr, "Error: wide characters found or printf() bug.");
        abort();
    }

    locale_decimal_point = buf[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
leaq 0x711a3(%rip), %rdx     # 0x1446bb
movsd 0x791c0(%rip), %xmm0    # 0x14c6e0
movb $0x1, %al
callq 0x26120
movsbl -0x8(%rbp), %eax
cmpl $0x30, %eax
jne 0xd3542
movsbl -0x6(%rbp), %eax
cmpl $0x35, %eax
jne 0xd3542
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
je 0xd355f
movq 0x9fa9f(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
leaq 0x791e4(%rip), %rsi     # 0x14c737
movb $0x0, %al
callq 0x26ba0
callq 0x261c0
movb -0x7(%rbp), %al
movb %al, 0xa4bc8(%rip)      # 0x178130
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohashGetCoordRange
void geohashGetCoordRange(GeoHashRange *long_range, GeoHashRange *lat_range) {
    /* These are constraints from EPSG:900913 / EPSG:3785 / OSGEO:41001 */
    /* We can't geocode at the north/south pole. */
    long_range->max = GEO_LONG_MAX;
    long_range->min = GEO_LONG_MIN;
    lat_range->max = GEO_LAT_MAX;
    lat_range->min = GEO_LAT_MIN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x75d98(%rip), %xmm0    # 0x149320
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x75d7f(%rip), %xmm0    # 0x149318
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x75d87(%rip), %xmm0    # 0x149330
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x75d6e(%rip), %xmm0    # 0x149328
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: interleave64
static inline uint64_t interleave64(uint32_t xlo, uint32_t ylo) {
    static const uint64_t B[] = {0x5555555555555555ULL, 0x3333333333333333ULL,
                                 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL,
                                 0x0000FFFF0000FFFFULL};
    static const unsigned int S[] = {1, 2, 4, 8, 16};

    uint64_t x = xlo;
    uint64_t y = ylo;

    x = (x | (x << S[4])) & B[4];
    y = (y | (y << S[4])) & B[4];

    x = (x | (x << S[3])) & B[3];
    y = (y | (y << S[3])) & B[3];

    x = (x | (x << S[2])) & B[2];
    y = (y | (y << S[2])) & B[2];

    x = (x | (x << S[1])) & B[1];
    y = (y | (y << S[1])) & B[1];

    x = (x | (x << S[0])) & B[0];
    y = (y | (y << S[0])) & B[0];

    return x | (y << 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x78fba(%rip), %ecx     # 0x14c7b0
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78f8a(%rip), %rax     # 0x14c790
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movl 0x78f98(%rip), %ecx     # 0x14c7b0
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78f68(%rip), %rax     # 0x14c790
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x78f72(%rip), %ecx     # 0x14c7ac
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78f3e(%rip), %rax     # 0x14c788
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movl 0x78f50(%rip), %ecx     # 0x14c7ac
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78f1c(%rip), %rax     # 0x14c788
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x78f2a(%rip), %ecx     # 0x14c7a8
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78ef2(%rip), %rax     # 0x14c780
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movl 0x78f08(%rip), %ecx     # 0x14c7a8
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78ed0(%rip), %rax     # 0x14c780
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x78ee2(%rip), %ecx     # 0x14c7a4
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78ea6(%rip), %rax     # 0x14c778
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movl 0x78ec0(%rip), %ecx     # 0x14c7a4
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78e84(%rip), %rax     # 0x14c778
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x78e9a(%rip), %ecx     # 0x14c7a0
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78e5a(%rip), %rax     # 0x14c770
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movl 0x78e78(%rip), %ecx     # 0x14c7a0
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq 0x78e38(%rip), %rax     # 0x14c770
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
orq %rcx, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/geohash-int/geohash.c
// Function: geohashDecodeAreaToLongLat
int geohashDecodeAreaToLongLat(const GeoHashArea *area, double *xy) {
    if (!xy) return 0;
    xy[0] = (area->longitude.min + area->longitude.max) / 2;
    xy[1] = (area->latitude.min + area->latitude.max) / 2;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd3ebc
movl $0x0, -0x4(%rbp)
jmp 0xd3f10
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd 0x6f97a(%rip), %xmm1    # 0x143850
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x28(%rax), %xmm0
movsd 0x6f954(%rip), %xmm1    # 0x143850
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x26110
cmpq $0x0, -0x20(%rbp)
je 0xd3f63
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movzbl -0x10(%rbp), %esi
callq 0xd3e00
cmpl $0x0, %eax
jne 0xd3f6c
movl $0x0, -0x4(%rbp)
jmp 0xd3f7c
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd3ea0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0xd41bc
jmp 0xd4282
movq -0x8(%rbp), %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
andq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
andq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %ecx
shll %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0xd422a
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xd4249
movq -0x18(%rbp), %rax
orq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %ecx
shll %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
shrq %cl, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
orq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0xd42ac
jmp 0xd4372
movq -0x8(%rbp), %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
andq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
andq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %ecx
shll %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0xd431a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xd4339
movq -0x20(%rbp), %rax
orq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %ecx
shll %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
shrq %cl, %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
orq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd43a7
jp 0xd43a7
movb $0x1a, -0x1(%rbp)
jmp 0xd445b
movl $0x1, -0x1c(%rbp)
movsd 0x78452(%rip), %xmm0    # 0x14c808
ucomisd -0x10(%rbp), %xmm0
jbe 0xd43da
movsd 0x6f48b(%rip), %xmm0    # 0x143850
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd43ae
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x78420(%rip), %xmm1    # 0x14c810
ucomisd %xmm1, %xmm0
ja 0xd4405
movsd 0x7841a(%rip), %xmm0    # 0x14c818
ucomisd -0x18(%rbp), %xmm0
jbe 0xd443b
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x78405(%rip), %xmm1    # 0x14c820
ucomisd %xmm1, %xmm0
ja 0xd4430
movsd 0x783ff(%rip), %xmm0    # 0x14c828
ucomisd -0x18(%rbp), %xmm0
jbe 0xd4439
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd443b
cmpl $0x1, -0x1c(%rbp)
jge 0xd4448
movl $0x1, -0x1c(%rbp)
cmpl $0x1a, -0x1c(%rbp)
jle 0xd4455
movl $0x1a, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd448e
movl $0x0, -0x4(%rbp)
jmp 0xd45a8
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x7838b(%rip), %xmm1    # 0x14c830
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xd45e0
callq 0x263d0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0xd45c0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x78337(%rip), %xmm1    # 0x14c830
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xd45e0
callq 0x263d0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0xd45c0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x782e2(%rip), %xmm1    # 0x14c830
divsd %xmm1, %xmm0
callq 0xd45c0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x782ad(%rip), %xmm1    # 0x14c830
divsd %xmm1, %xmm0
callq 0xd45c0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0xd45e0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0xd45e0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0xd45e0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xd45e0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd 0x6ed76(%rip), %xmm1    # 0x143850
divsd %xmm1, %xmm0
callq 0x26ca0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd 0x6ed56(%rip), %xmm1    # 0x143850
divsd %xmm1, %xmm0
callq 0x26ca0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x263d0
movsd %xmm0, -0x68(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x263d0
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x58(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd -0x50(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x26c20
callq 0x265a0
movaps %xmm0, %xmm1
movsd 0x77cc6(%rip), %xmm0    # 0x14c838
mulsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xe498(%rip)      # 0x12d58
je 0x48f3
movq 0xe48f(%rip), %rax      # 0x12d58
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0xe480(%rip), %rdi      # 0x12d58
movq -0x8(%rbp), %rsi
callq 0xaf90
movq %rax, 0xe470(%rip)      # 0x12d58
movq -0x8(%rbp), %rdi
callq 0x42e0
jmp 0x48b8
movl $0x0, -0xc(%rbp)
cmpl $0x26, -0xc(%rbp)
jge 0x493b
movslq -0xc(%rbp), %rcx
leaq 0xdba5(%rip), %rax      # 0x124b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xdb90(%rip), %rax      # 0x124b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x4950
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x48fa
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cfc
jmp 0x4db2
movq -0x8(%rbp), %rdi
callq 0x4dc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4d15
jmp 0x4db2
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xd9c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x9310(%rip), %rsi      # 0xe048
callq 0x4590
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4d87
movq -0x28(%rbp), %rdi
callq 0x4dc0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4d6f
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x4d71
jmp 0x4d71
xorl %eax, %eax
movl %eax, %edi
leaq 0x92cc(%rip), %rsi      # 0xe048
callq 0x4590
movq %rax, -0x28(%rbp)
jmp 0x4d41
movq -0x20(%rbp), %rdi
callq 0x42e0
movq -0x8(%rbp), %rdi
leaq 0x9275(%rip), %rsi      # 0xe010
callq 0x4550
cmpl $0x0, %eax
jne 0x4db2
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xd666(%rip)      # 0x12418
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x4e21
movslq -0x14(%rbp), %rcx
leaq 0xd60c(%rip), %rax      # 0x123f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
cmpl $0x0, %eax
jne 0x4e14
movslq -0x14(%rbp), %rcx
leaq 0xd5e9(%rip), %rax      # 0x123f0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4e29
jmp 0x4e16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4dd3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/bind.c
// Function: button_by_name
static unsigned button_by_name(const char *name) {
	for (int i = 0; i < NUM_NAME_TO_BUTTON; i++) {
		if (!strcmp(name_to_button[i].name, name)) {
			return name_to_button[i].button;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x4ea3
movslq -0x14(%rbp), %rcx
leaq 0xd8ac(%rip), %rax      # 0x12710
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
cmpl $0x0, %eax
jne 0x4e96
movslq -0x14(%rbp), %rcx
leaq 0xd889(%rip), %rax      # 0x12710
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4eaa
jmp 0x4e98
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e53
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/bind.c
// Function: func_by_name
static struct function_def *func_by_name(const char *name) {
	for (int i = 0; i < NUM_NAME_TO_FUNC; i++) {
		if (!strcmp(name_to_func[i].name, name)) {
			return &name_to_func[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x4f21
movslq -0x14(%rbp), %rcx
leaq 0xd87c(%rip), %rax      # 0x12760
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
cmpl $0x0, %eax
jne 0x4f14
movslq -0x14(%rbp), %rcx
leaq 0xd859(%rip), %rax      # 0x12760
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4f29
jmp 0x4f16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ed3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/bind.c
// Function: flags_by_name
static unsigned flags_by_name(const char *name) {
	for (int i = 0; i < NUM_NAME_TO_FLAGS; i++) {
		if (!strcmp(name_to_flags[i].name, name)) {
			return name_to_flags[i].flags;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xd, -0x14(%rbp)
jge 0x4fa3
movslq -0x14(%rbp), %rcx
leaq 0xd91c(%rip), %rax      # 0x12880
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
cmpl $0x0, %eax
jne 0x4f96
movslq -0x14(%rbp), %rcx
leaq 0xd8f9(%rip), %rax      # 0x12880
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4faa
jmp 0x4f98
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f53
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xddad(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x4250
movq 0xdd67(%rip), %rax      # 0x12d58
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x503c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x502d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x5050
jmp 0x502f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4ff5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/bind.c
// Function: grab_keysym
static void grab_keysym(KeySym keysym, unsigned modmask, Window w) {
	KeyCode keycode = XKeysymToKeycode(display.dpy, keysym);
	XGrabKey(display.dpy, keycode, modmask, w, True,
		 GrabModeAsync, GrabModeAsync);
	XGrabKey(display.dpy, keycode, modmask|LockMask, w, True,
		 GrabModeAsync, GrabModeAsync);
	if (numlockmask) {
		XGrabKey(display.dpy, keycode, modmask|numlockmask, w, True,
			 GrabModeAsync, GrabModeAsync);
		XGrabKey(display.dpy, keycode, modmask|numlockmask|LockMask, w, True,
			 GrabModeAsync, GrabModeAsync);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xdd16(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4620
movb %al, -0x19(%rbp)
leaq 0xdd00(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x4670
leaq 0xdcd6(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
orl $0x2, %edx
movq -0x18(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x4670
leaq 0xde59(%rip), %rax      # 0x12f30
cmpl $0x0, (%rax)
je 0x5145
leaq 0xdc9d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xde3c(%rip), %rax      # 0x12f30
orl (%rax), %edx
movq -0x18(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x4670
leaq 0xdc6a(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xde09(%rip), %rax      # 0x12f30
orl (%rax), %edx
orl $0x2, %edx
movq -0x18(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x4670
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xdbf5(%rip), %rax      # 0x12d58
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x51cc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x51bd
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movl 0xd278(%rip), %esi      # 0x12408
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x51e0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movl 0xd25e(%rip), %esi      # 0x12408
orl 0xd268(%rip), %esi      # 0x12418
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x51e0
jmp 0x51bf
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5167
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0xdb87(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x4630
leaq 0xdb42(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
orl $0x2, %edx
movq -0x10(%rbp), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x4630
leaq 0xdcaa(%rip), %rax      # 0x12f30
cmpl $0x0, (%rax)
je 0x532e
leaq 0xdaea(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0xdc8a(%rip), %rax      # 0x12f30
orl (%rax), %edx
movq -0x10(%rbp), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x4630
leaq 0xda9c(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0xdc3c(%rip), %rax      # 0x12f30
orl (%rax), %edx
orl $0x2, %edx
movq -0x10(%rbp), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x4630
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xda2d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
xorl %ecx, %ecx
movzbl %al, %esi
movl %ecx, %edx
callq 0x4270
movq %rax, -0x10(%rbp)
movq 0xd9e4(%rip), %rax      # 0x12d58
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5467
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x5455
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5455
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl $0xfd, %eax
leaq 0xdb6f(%rip), %rcx      # 0x12f30
movl (%rcx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %ecx
leaq 0xdb5a(%rip), %rdx      # 0x12f30
movl (%rdx), %edx
xorl $-0x1, %edx
andl %edx, %ecx
cmpl %ecx, %eax
jne 0x5455
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x5413
leaq 0xd977(%rip), %rax      # 0x12d78
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5411
jmp 0x5467
jmp 0x543a
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x5438
callq 0xca90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5436
jmp 0x5467
jmp 0x5438
jmp 0x543a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl 0x20(%rcx), %edx
callq *%rax
jmp 0x5467
jmp 0x5457
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5378
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xd8d5(%rip), %rax      # 0x12d58
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x557c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x556a
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x556a
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl 0xcf3c(%rip), %ecx      # 0x12408
xorl $-0x1, %ecx
andl $0xfd, %ecx
andl %ecx, %eax
leaq 0xda52(%rip), %rcx      # 0x12f30
movl (%rcx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
leaq 0xda3d(%rip), %rdx      # 0x12f30
movl (%rdx), %edx
xorl $-0x1, %edx
andl %edx, %ecx
cmpl %ecx, %eax
jne 0x556a
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x552a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5820
movq %rax, -0x20(%rbp)
jmp 0x5546
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x5544
callq 0xca90
movq %rax, -0x20(%rbp)
jmp 0x5546
cmpq $0x0, -0x20(%rbp)
jne 0x554f
jmp 0x557c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %edx
callq *%rax
jmp 0x557c
jmp 0x556c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5487
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0xd531(%rip), %rax      # 0x12d60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x587a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x5861
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x586b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5882
jmp 0x586d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5833
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/client.c
// Function: set_wm_state
void set_wm_state(struct client *c, int state) {
	// Using "long" for the type of "data" looks wrong, but the fine people
	// in the X Consortium defined it this way (even on 64-bit machines).
	long data[2] = { state, None };
	XChangeProperty(display.dpy, c->window, X_ATOM(WM_STATE), X_ATOM(WM_STATE), 32,
			PropModeReplace, (unsigned char *)data, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xd15a(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xd149(%rip), %rax      # 0x12d80
movq 0x8(%rax), %rdx
leaq 0xd13e(%rip), %rax      # 0x12d80
movq 0x8(%rax), %rcx
leaq -0x20(%rbp), %rax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x4650
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd0bd(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4190
movq 0xd096(%rip), %rdi      # 0x12d70
movq -0x8(%rbp), %rsi
callq 0xb070
movq %rax, 0xd086(%rip)      # 0x12d70
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9ea0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)