// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/corelib.c
// Function: janet_core_env
JanetTable *janet_core_env(JanetTable *replacements) {
    JanetTable *env = (NULL != replacements) ? replacements : janet_table(0);
    janet_quick_asm(env, JANET_FUN_CMP,
                    "cmp", 2, 2, 2, 2, cmp_asm, sizeof(cmp_asm),
                    JDOC("(cmp x y)\n\n"
         "Returns -1 if x is strictly less than y, 1 if y is strictly greater "
         "than x, and 0 otherwise. To return 0, x and y must be the exact same type."));
    janet_quick_asm(env, JANET_FUN_NEXT,
                    "next", 2, 1, 2, 2, next_asm, sizeof(next_asm),
                    JDOC("(next ds &opt key)\n\n"
         "Gets the next key in a data structure. Can be used to iterate through "
         "the keys of a data structure in an unspecified order. Keys are guaranteed "
         "to be seen only once per iteration if the data structure is not mutated "
         "during iteration. If key is nil, next returns the first key. If next "
         "returns nil, there are no more keys to iterate through."));
    janet_quick_asm(env, JANET_FUN_PROP,
                    "propagate", 2, 2, 2, 2, propagate_asm, sizeof(propagate_asm),
                    JDOC("(propagate x fiber)\n\n"
         "Propagate a signal from a fiber to the current fiber and "
         "set the last value of the current fiber to `x`.  The signal "
         "value is then available as the status of the current fiber. "
         "The resulting stack trace from the current fiber will include "
         "frames from fiber. If fiber is in a state that can be resumed, "
         "resuming the current fiber will first resume `fiber`. "
         "This function can be used to re-raise an error without losing "
         "the original stack trace."));
    janet_quick_asm(env, JANET_FUN_DEBUG,
                    "debug", 1, 0, 1, 1, debug_asm, sizeof(debug_asm),
                    JDOC("(debug &opt x)\n\n"
         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
         "the running state of the current fiber. Returns the value passed in by resume."));
    janet_quick_asm(env, JANET_FUN_ERROR,
                    "error", 1, 1, 1, 1, error_asm, sizeof(error_asm),
                    JDOC("(error e)\n\n"
         "Throws an error e that can be caught and handled by a parent fiber."));
    janet_quick_asm(env, JANET_FUN_YIELD,
                    "yield", 1, 0, 1, 2, yield_asm, sizeof(yield_asm),
                    JDOC("(yield &opt x)\n\n"
         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
         "another thread resumes it. The fiber will then resume, and the last yield call will "
         "return the value that was passed to resume."));
    janet_quick_asm(env, JANET_FUN_CANCEL,
                    "cancel", 2, 2, 2, 2, cancel_asm, sizeof(cancel_asm),
                    JDOC("(cancel fiber err)\n\n"
         "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. "
         "Returns the same result as resume."));
    janet_quick_asm(env, JANET_FUN_RESUME,
                    "resume", 2, 1, 2, 2, resume_asm, sizeof(resume_asm),
                    JDOC("(resume fiber &opt x)\n\n"
         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
         "will be returned to the last yield in the case of a pending fiber, or the argument to "
         "the dispatch function in the case of a new fiber. Returns either the return result of "
         "the fiber's dispatch function, or the value from the next yield call in fiber."));
    janet_quick_asm(env, JANET_FUN_IN,
                    "in", 3, 2, 3, 4, in_asm, sizeof(in_asm),
                    JDOC("(in ds key &opt dflt)\n\n"
         "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, "
         "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, "
         "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can "
         "take any value as a key except nil and will return nil or dflt if not found."));
    janet_quick_asm(env, JANET_FUN_GET,
                    "get", 3, 2, 3, 4, get_asm, sizeof(in_asm),
                    JDOC("(get ds key &opt dflt)\n\n"
         "Get the value mapped to key in data structure ds, and return dflt or nil if not found. "
         "Similar to in, but will not throw an error if the key is invalid for the data structure "
         "unless the data structure is an abstract type. In that case, the abstract type getter may throw "
         "an error."));
    janet_quick_asm(env, JANET_FUN_PUT,
                    "put", 3, 3, 3, 3, put_asm, sizeof(put_asm),
                    JDOC("(put ds key value)\n\n"
         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
    janet_quick_asm(env, JANET_FUN_LENGTH,
                    "length", 1, 1, 1, 1, length_asm, sizeof(length_asm),
                    JDOC("(length ds)\n\n"
         "Returns the length or count of a data structure in constant time as an integer. For "
         "structs and tables, returns the number of key-value pairs in the data structure."));
    janet_quick_asm(env, JANET_FUN_BNOT,
                    "bnot", 1, 1, 1, 1, bnot_asm, sizeof(bnot_asm),
                    JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x."));
    make_apply(env);

    /* Variadic ops */
    templatize_varop(env, JANET_FUN_ADD, "+", 0, 0, JOP_ADD,
                     JDOC("(+ & xs)\n\n"
         "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
    templatize_varop(env, JANET_FUN_SUBTRACT, "-", 0, 0, JOP_SUBTRACT,
                     JDOC("(- & xs)\n\n"
         "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
         "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
         "the rest of the elements."));
    templatize_varop(env, JANET_FUN_MULTIPLY, "*", 1, 1, JOP_MULTIPLY,
                     JDOC("(* & xs)\n\n"
         "Returns the product of all elements in xs. If xs is empty, returns 1."));
    templatize_varop(env, JANET_FUN_DIVIDE, "/", 1, 1, JOP_DIVIDE,
                     JDOC("(/ & xs)\n\n"
         "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
         "values."));
    templatize_varop(env, JANET_FUN_DIVIDE_FLOOR, "div", 1, 1, JOP_DIVIDE_FLOOR,
                     JDOC("(div & xs)\n\n"
         "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
         "values."));
    templatize_varop(env, JANET_FUN_MODULO, "mod", 0, 1, JOP_MODULO,
                     JDOC("(mod & xs)\n\n"
         "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
         "`(mod x 0)` is defined to be `x`."));
    templatize_varop(env, JANET_FUN_REMAINDER, "%", 0, 1, JOP_REMAINDER,
                     JDOC("(% & xs)\n\n"
         "Returns the remainder of dividing the first value of xs by each remaining value."));
    templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND,
                     JDOC("(band & xs)\n\n"
         "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
    templatize_varop(env, JANET_FUN_BOR, "bor", 0, 0, JOP_BOR,
                     JDOC("(bor & xs)\n\n"
         "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
    templatize_varop(env, JANET_FUN_BXOR, "bxor", 0, 0, JOP_BXOR,
                     JDOC("(bxor & xs)\n\n"
         "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
    templatize_varop(env, JANET_FUN_LSHIFT, "blshift", 1, 1, JOP_SHIFT_LEFT,
                     JDOC("(blshift x & shifts)\n\n"
         "Returns the value of x bit shifted left by the sum of all values in shifts. x "
         "and each element in shift must be an integer."));
    templatize_varop(env, JANET_FUN_RSHIFT, "brshift", 1, 1, JOP_SHIFT_RIGHT,
                     JDOC("(brshift x & shifts)\n\n"
         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
         "and each element in shift must be an integer."));
    templatize_varop(env, JANET_FUN_RSHIFTU, "brushift", 1, 1, JOP_SHIFT_RIGHT_UNSIGNED,
                     JDOC("(brushift x & shifts)\n\n"
         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
         "and each element in shift must be an integer. The sign of x is not preserved, so "
         "for positive shifts the return value will always be positive."));

    /* Variadic comparators */
    templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_GREATER_THAN,
                          JDOC("(> & xs)\n\n"
         "Check if xs is in descending order. Returns a boolean."));
    templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_LESS_THAN,
                          JDOC("(< & xs)\n\n"
         "Check if xs is in ascending order. Returns a boolean."));
    templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_GREATER_THAN_EQUAL,
                          JDOC("(>= & xs)\n\n"
         "Check if xs is in non-ascending order. Returns a boolean."));
    templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_LESS_THAN_EQUAL,
                          JDOC("(<= & xs)\n\n"
         "Check if xs is in non-descending order. Returns a boolean."));
    templatize_comparator(env, JANET_FUN_EQ, "=", 0, JOP_EQUALS,
                          JDOC("(= & xs)\n\n"
         "Check if all values in xs are equal. Returns a boolean."));
    templatize_comparator(env, JANET_FUN_NEQ, "not=", 1, JOP_EQUALS,
                          JDOC("(not= & xs)\n\n"
         "Check if any values in xs are not equal. Returns a boolean."));

    /* Platform detection */
    janet_def(env, "janet/version", janet_cstringv(JANET_VERSION),
              JDOC("The version number of the running janet program."));
    janet_def(env, "janet/build", janet_cstringv(JANET_BUILD),
              JDOC("The build identifier of the running janet program."));
    janet_def(env, "janet/config-bits", janet_wrap_integer(JANET_CURRENT_CONFIG_BITS),
              JDOC("The flag set of config options from janetconf.h which is used to check "
         "if native modules are compatible with the host program."));

    /* Allow references to the environment */
    janet_def(env, "root-env", janet_wrap_table(env),
              JDOC("The root environment used to create environments with (make-env)."));

    janet_load_libs(env);
    janet_gcroot(janet_wrap_table(env));
    return env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x26c31
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x26c3c
xorl %edi, %edi
callq 0x692f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1f, %esi
leaq 0x5c95b(%rip), %rdx     # 0x835af
movl $0x2, %r9d
leaq 0x5c95f(%rip), %r10     # 0x835c0
leaq 0x5ae9c(%rip), %rax     # 0x81b04
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
leaq 0x66607(%rip), %rdx     # 0x8d2a4
movl $0x2, %r9d
movl $0x1, %r8d
leaq 0x5c918(%rip), %r10     # 0x835c8
leaq 0x5aee7(%rip), %rax     # 0x81b9e
movl %r9d, %ecx
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
leaq 0x5b01e(%rip), %rdx     # 0x81d07
movl $0x2, %r9d
leaq 0x5c8da(%rip), %r10     # 0x835d0
leaq 0x5b014(%rip), %rax     # 0x81d11
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x1, %r9d
leaq 0x5b1af(%rip), %rdx     # 0x81ee2
xorl %r8d, %r8d
leaq 0x5c89b(%rip), %r10     # 0x835d8
leaq 0x5b1a4(%rip), %rax     # 0x81ee8
movl %r9d, %esi
movl %r9d, %ecx
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x6eeb5(%rip), %rdx     # 0x95c2e
movl $0x1, %r9d
leaq 0x5c85a(%rip), %r10     # 0x835e0
leaq 0x5b209(%rip), %rax     # 0x81f96
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x4, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x4, %esi
leaq 0x5b223(%rip), %rdx     # 0x81fe5
movl $0x1, %r9d
xorl %r8d, %r8d
leaq 0x5c812(%rip), %r10     # 0x835e4
leaq 0x5b212(%rip), %rax     # 0x81feb
movl %r9d, %ecx
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x20, %esi
leaq 0x7241e(%rip), %rdx     # 0x99229
movl $0x2, %r9d
leaq 0x5c7d4(%rip), %r10     # 0x835ec
leaq 0x5b2b0(%rip), %rax     # 0x820cf
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0x5b318(%rip), %rdx     # 0x8216c
movl $0x2, %r9d
movl $0x1, %r8d
leaq 0x5c78d(%rip), %r10     # 0x835f4
leaq 0x5b305(%rip), %rax     # 0x82173
movl %r9d, %ecx
movl $0x2, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x6, %esi
leaq 0x5e522(%rip), %rdx     # 0x853c2
movl $0x3, %r9d
movl $0x2, %r8d
leaq 0x5c74d(%rip), %r10     # 0x83600
leaq 0x5b41c(%rip), %rax     # 0x822d6
movl %r9d, %ecx
movl $0x4, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x18, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x1b, %esi
leaq 0x70ea0(%rip), %rdx     # 0x97d8c
movl $0x3, %r9d
movl $0x2, %r8d
leaq 0x5c721(%rip), %r10     # 0x83620
leaq 0x5b55b(%rip), %rax     # 0x82461
movl %r9d, %ecx
movl $0x4, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x18, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x7, %esi
leaq 0x588c3(%rip), %rdx     # 0x7f7fb
movl $0x3, %r9d
leaq 0x5c6f3(%rip), %r10     # 0x83638
leaq 0x5b646(%rip), %rax     # 0x82592
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x3, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x8, %esi
leaq 0x6e369(%rip), %rdx     # 0x952ea
movl $0x1, %r9d
leaq 0x5c6b2(%rip), %r10     # 0x83640
leaq 0x5b855(%rip), %rax     # 0x827ea
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
movl $0x13, %esi
leaq 0x58755(%rip), %rdx     # 0x7f71f
movl $0x1, %r9d
leaq 0x5c671(%rip), %r10     # 0x83648
leaq 0x5b8be(%rip), %rax     # 0x8289c
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x27470
movq -0x10(%rbp), %rdi
callq 0x275c0
movq -0x10(%rbp), %rdi
movl $0x9, %esi
leaq 0x63f7d(%rip), %rdx     # 0x8af99
xorl %r8d, %r8d
movl $0x6, %r9d
leaq 0x5b8a5(%rip), %rax     # 0x828d1
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xa, %esi
leaq 0x6e38f(%rip), %rdx     # 0x953d7
xorl %r8d, %r8d
movl $0x8, %r9d
leaq 0x5b8e2(%rip), %rax     # 0x8293a
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xb, %esi
leaq 0x63f2b(%rip), %rdx     # 0x8af9f
movl $0x1, %r8d
movl $0xa, %r9d
leaq 0x5b98f(%rip), %rax     # 0x82a16
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xc, %r9d
leaq 0x63efe(%rip), %rdx     # 0x8afa2
movl $0x1, %r8d
leaq 0x5b9b5(%rip), %rax     # 0x82a66
movl %r9d, %esi
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x21, %esi
leaq 0x63ed5(%rip), %rdx     # 0x8afa5
movl $0x1, %r8d
movl $0xd, %r9d
leaq 0x5ba4b(%rip), %rax     # 0x82b2e
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
leaq 0x6c2fb(%rip), %rdx     # 0x933fa
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0xe, %r9d
leaq 0x5baec(%rip), %rax     # 0x82c00
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x1e, %esi
leaq 0x6c0fb(%rip), %rdx     # 0x93228
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0xf, %r9d
leaq 0x5bb53(%rip), %rax     # 0x82c95
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xd, %esi
leaq 0x585bf(%rip), %rdx     # 0x7f71a
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x10, %r9d
leaq 0x5bb82(%rip), %rax     # 0x82cf0
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xe, %esi
leaq 0x5859a(%rip), %rdx     # 0x7f724
xorl %r8d, %r8d
movl $0x11, %r9d
leaq 0x5bbb2(%rip), %rax     # 0x82d4c
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x58572(%rip), %rdx     # 0x7f728
xorl %r8d, %r8d
movl $0x12, %r9d
leaq 0x5bbe0(%rip), %rax     # 0x82da6
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x10, %esi
leaq 0x5bc1e(%rip), %rdx     # 0x82e00
movl $0x1, %r8d
movl $0x14, %r9d
leaq 0x5bc13(%rip), %rax     # 0x82e08
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x11, %esi
leaq 0x5bc89(%rip), %rdx     # 0x82e9a
movl $0x1, %r8d
movl $0x16, %r9d
leaq 0x5bc7e(%rip), %rax     # 0x82ea2
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x12, %esi
leaq 0x5bcf5(%rip), %rdx     # 0x82f35
movl $0x1, %r8d
movl $0x18, %r9d
leaq 0x5bceb(%rip), %rax     # 0x82f3e
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x27630
movq -0x10(%rbp), %rdi
movl $0x14, %esi
leaq 0x6e165(%rip), %rdx     # 0x953d4
xorl %ecx, %ecx
movl $0x21, %r8d
leaq 0x5bdb5(%rip), %r9      # 0x83033
callq 0x27760
movq -0x10(%rbp), %rdi
movl $0x15, %esi
leaq 0x71dca(%rip), %rdx     # 0x9905d
xorl %ecx, %ecx
movl $0x23, %r8d
leaq 0x5bdd2(%rip), %r9      # 0x83074
callq 0x27760
movq -0x10(%rbp), %rdi
movl $0x16, %esi
leaq 0x5bdfd(%rip), %rdx     # 0x830b4
xorl %ecx, %ecx
movl $0x47, %r8d
leaq 0x5bdf1(%rip), %r9      # 0x830b7
callq 0x27760
movq -0x10(%rbp), %rdi
movl $0x17, %esi
leaq 0x5be21(%rip), %rdx     # 0x830fc
xorl %ecx, %ecx
movl $0x48, %r8d
leaq 0x5be15(%rip), %r9      # 0x830ff
callq 0x27760
movq -0x10(%rbp), %rdi
movl $0x18, %esi
leaq 0x5bdfe(%rip), %rdx     # 0x830fd
xorl %ecx, %ecx
movl $0x25, %r8d
leaq 0x5be37(%rip), %r9      # 0x83145
callq 0x27760
movq -0x10(%rbp), %rdi
movl $0x19, %esi
leaq 0x5be64(%rip), %rdx     # 0x83187
movl $0x1, %ecx
movl $0x25, %r8d
leaq 0x5be57(%rip), %r9      # 0x8318c
callq 0x27760
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x5be9a(%rip), %rdi     # 0x831e3
callq 0x64a70
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x5be62(%rip), %rsi     # 0x831d5
leaq 0x5be70(%rip), %rcx     # 0x831ea
callq 0x6b670
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x5be99(%rip), %rdi     # 0x83227
callq 0x64a70
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq 0x5be63(%rip), %rsi     # 0x8321b
leaq 0x5be71(%rip), %rcx     # 0x83230
callq 0x6b670
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0x59f4c(%rip), %xmm0    # 0x81320
callq 0x7b820
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq 0x5be77(%rip), %rsi     # 0x83263
leaq 0x5be82(%rip), %rcx     # 0x83275
callq 0x6b670
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x7b610
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
leaq 0x5bece(%rip), %rsi     # 0x832f4
leaq 0x5bed0(%rip), %rcx     # 0x832fd
callq 0x6b670
movq -0x10(%rbp), %rdi
callq 0x27880
movq -0x10(%rbp), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x7b610
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39200
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)