LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: loadzero[P]geoloc/geoloc/error.cpp
// Function: log_context(char const*, unsigned int, char const*, ...)
void log_context(const char* file, unsigned line, const char* fmt, ...)
{
    va_list ap;
    int n = 0;

    va_start(ap, fmt);
    n = vsnprintf(print_buf_, 4096, fmt, ap);
    va_end(ap);

    if (n > 4095) n = 4095;

    // replace the nul terminator with a new line

    print_buf_[n] = '\n';

    memcpy(error_buf_ + error_offset_, print_buf_, n + 1);
    memcpy(error_buf_ + error_offset_ + 4096, print_buf_, n + 1);

    error_offset_ += n+1;
    error_offset_ = error_offset_ % 4096;

    avail_ += (n+1);

    if (avail_ > 4096)
    {
        avail_ = 4096;
    }
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x1b68c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq %rdx, 0xe0(%rsp)
movl $0x0, 0xbc(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xe0(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
leaq 0xbbf4(%rip), %rdi      # 0x272f0
movl $0x1000, %esi           # imm = 0x1000
callq 0x41b0
movl %eax, 0xbc(%rsp)
leaq 0xc0(%rsp), %rax
cmpl $0xfff, 0xbc(%rsp) # imm = 0xFFF
jle 0x1b72d
movl $0xfff, 0xbc(%rsp) # imm = 0xFFF
movslq 0xbc(%rsp), %rcx
leaq 0xbbb4(%rip), %rax      # 0x272f0
movb $0xa, (%rax,%rcx)
leaq 0xcba9(%rip), %rdi      # 0x282f0
addq 0xeba2(%rip), %rdi      # 0x2a2f0
movl 0xbc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0xbb8e(%rip), %rsi      # 0x272f0
callq 0x4230
leaq 0xcb82(%rip), %rdi      # 0x282f0
addq 0xeb7b(%rip), %rdi      # 0x2a2f0
addq $0x1000, %rdi           # imm = 0x1000
movl 0xbc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0xbb60(%rip), %rsi      # 0x272f0
callq 0x4230
movl 0xbc(%rsp), %eax
addl $0x1, %eax
cltq
addq 0xeb48(%rip), %rax      # 0x2a2f0
movq %rax, 0xeb41(%rip)      # 0x2a2f0
movq 0xeb3a(%rip), %rax      # 0x2a2f0
andq $0xfff, %rax            # imm = 0xFFF
movq %rax, 0xeb2d(%rip)      # 0x2a2f0
movl 0xbc(%rsp), %eax
addl $0x1, %eax
cltq
addq 0xeb22(%rip), %rax      # 0x2a2f8
movq %rax, 0xeb1b(%rip)      # 0x2a2f8
cmpq $0x1000, 0xeb10(%rip) # imm = 0x1000
jbe 0x1b7f5
movq $0x1000, 0xeb03(%rip) # imm = 0x1000
addq $0xf8, %rsp
retq
nopl (%rax)
// File: loadzero[P]geoloc/geoloc/error.cpp
// Function: fatal_error(char const*, unsigned int, char const*, ...)
void fatal_error(const char* file, unsigned line, const char* fmt, ...)
{
    va_list ap;
    fprintf(stderr, "%s:%d: error: ", file, line);

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    fprintf(stderr, "\n");

    if (avail_)
    {
        fprintf(stderr, "context:\n");
        log_dump();
    }

    exit(1);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x1b83c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xb76f(%rip), %rax      # 0x26fd8
movq (%rax), %rdi
movq 0xe0(%rsp), %rdx
movl 0xdc(%rsp), %ecx
leaq 0x1101(%rip), %rsi      # 0x1c983
movb $0x0, %al
callq 0x4430
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xb720(%rip), %rax      # 0x26fd8
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x43b0
leaq 0xb0(%rsp), %rax
movq 0xb6f9(%rip), %rax      # 0x26fd8
movq (%rax), %rdi
leaq 0x884(%rip), %rsi       # 0x1c16d
movb $0x0, %al
callq 0x4430
cmpq $0x0, 0xea00(%rip)      # 0x2a2f8
je 0x1b917
movq 0xb6d7(%rip), %rax      # 0x26fd8
movq (%rax), %rdi
leaq 0x1087(%rip), %rsi      # 0x1c992
movb $0x0, %al
callq 0x4430
callq 0x1b930
movl $0x1, %edi
callq 0x4330
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day01/ex00/main.cpp
// Function: main
int main(void)
{
	std::cout << "Pony on the stack, doesn't call any destructor" << std::endl;
	ponyOnTheStack();
	std::cout << std::endl << "Pony on the heap, call delete" << std::endl;
	ponyOnTheHeap();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x281d(%rip), %rdi      # 0x4fd8
leaq 0x893(%rip), %rsi       # 0x3055
callq 0x20f0
movq %rax, %rdi
movq 0x27f7(%rip), %rsi      # 0x4fc8
callq 0x2120
callq 0x2670
movq 0x27f6(%rip), %rdi      # 0x4fd8
movq 0x27df(%rip), %rsi      # 0x4fc8
callq 0x2120
movq %rax, %rdi
leaq 0x88c(%rip), %rsi       # 0x3084
callq 0x20f0
movq %rax, %rdi
movq 0x27c1(%rip), %rsi      # 0x4fc8
callq 0x2120
callq 0x2510
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: genprivkey(char const*, vector<char>&, vector<char>&)
void genprivkey(const char *seed, vector<char> &privstr, vector<char> &pubstr)
{
    tiger::hashval hash;
    tiger::hash((const uchar *)seed, (int)strlen(seed), hash);
    bigint<8*sizeof(hash.bytes)/BI_DIGIT_BITS> privkey;
    memcpy(privkey.digits, hash.bytes, sizeof(privkey.digits));
    privkey.len = 8*sizeof(hash.bytes)/BI_DIGIT_BITS;
    privkey.shrink();
    privkey.printdigits(privstr);
    privstr.add('\0');

    ecjacobian c(ecjacobian::base);
    c.mul(privkey);
    c.normalize();
    c.print(pubstr);
    pubstr.add('\0');
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rdi
callq 0x1070
movq 0x28(%rsp), %rdi
movl %eax, %esi
leaq 0xd8(%rsp), %rdx
callq 0x8480
leaq 0xbc(%rsp), %rdi
callq 0x93b0
movq 0xd8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movl $0xc, 0xbc(%rsp)
leaq 0xbc(%rsp), %rdi
callq 0x93c0
movq 0xf8(%rsp), %rsi
leaq 0xbc(%rsp), %rdi
callq 0x9420
movq 0xf8(%rsp), %rdi
movb $0x0, 0xbb(%rsp)
leaq 0xbb(%rsp), %rsi
callq 0x9510
leaq 0x58(%rsp), %rdi
leaq 0xa924(%rip), %rsi      # 0x13184
movl $0x60, %edx
callq 0x10c0
movq 0xbc(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc4(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xcc(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0xd4(%rsp), %eax
movl %eax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x18(%rsp)
callq 0x9570
leaq 0x58(%rsp), %rdi
callq 0x9610
movq 0xf0(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x96d0
movq 0xf0(%rsp), %rdi
movb $0x0, 0x37(%rsp)
leaq 0x37(%rsp), %rsi
callq 0x9510
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: hashstring(char const*, char*, int)
bool hashstring(const char *str, char *result, int maxlen)
{
    tiger::hashval hv;
    if(maxlen < 2*(int)sizeof(hv.bytes) + 1) return false;
    tiger::hash((uchar *)str, strlen(str), hv);
    loopi(sizeof(hv.bytes))
    {
        uchar c = hv.bytes[i];
        *result++ = "0123456789abcdef"[c&0xF];
        *result++ = "0123456789abcdef"[c>>4];
    }
    *result = '\0';
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x31, 0x2c(%rsp)
jge 0x8933
movb $0x0, 0x47(%rsp)
jmp 0x89dc
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x1070
movq (%rsp), %rdi
movl %eax, %esi
leaq 0x10(%rsp), %rdx
callq 0x8480
movl $0x0, 0xc(%rsp)
cmpl $0x18, 0xc(%rsp)
jge 0x89cf
movslq 0xc(%rsp), %rax
movb 0x10(%rsp,%rax), %al
movb %al, 0xb(%rsp)
movzbl 0xb(%rsp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x57a1(%rip), %rax      # 0xe125
movb (%rax,%rcx), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, (%rax)
movzbl 0xb(%rsp), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x5779(%rip), %rax      # 0xe125
movb (%rax,%rcx), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x895e
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: answerchallenge(char const*, char const*, vector<char>&)
void answerchallenge(const char *privstr, const char *challenge, vector<char> &answerstr)
{
    gfint privkey;
    privkey.parse(privstr);
    ecjacobian answer;
    answer.parse(challenge);
    answer.mul(privkey);
    answer.normalize();
    answer.x.printdigits(answerstr);
    answerstr.add('\0');
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x9750
movq 0xe0(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x9760
leaq 0x50(%rsp), %rdi
callq 0x97a0
movq 0xd8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x97e0
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x9860
leaq 0x50(%rsp), %rdi
callq 0x9610
leaq 0x50(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0x9900
movq 0xd0(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
leaq 0x2f(%rsp), %rsi
callq 0x9510
addq $0xe8, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: genchallenge(void*, void const*, int, vector<char>&)
void *genchallenge(void *pubkey, const void *seed, int seedlen, vector<char> &challengestr)
{
    tiger::hashval hash;
    tiger::hash((const uchar *)seed, sizeof(seed), hash);
    gfint challenge;
    memcpy(challenge.digits, hash.bytes, sizeof(challenge.digits));
    challenge.len = 8*sizeof(hash.bytes)/BI_DIGIT_BITS;
    challenge.shrink();

    ecjacobian answer(*(ecjacobian *)pubkey);
    answer.mul(challenge);
    answer.normalize();

    ecjacobian secret(ecjacobian::base);
    secret.mul(challenge);
    secret.normalize();

    secret.print(challengestr);
    challengestr.add('\0');
   
    return new gfield(answer.x);
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movl %edx, 0x174(%rsp)
movq %rcx, 0x168(%rsp)
movq 0x178(%rsp), %rdi
movl $0x8, %esi
leaq 0x150(%rsp), %rdx
callq 0x8480
leaq 0x130(%rsp), %rdi
callq 0x9750
movq 0x150(%rsp), %rax
movq %rax, 0x134(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x13c(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x144(%rsp)
movw 0x168(%rsp), %ax
movw %ax, 0x14c(%rsp)
movl $0xc, 0x130(%rsp)
leaq 0x130(%rsp), %rdi
callq 0x9a20
movq 0x180(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
movl $0x60, %edx
callq 0x10c0
movq 0x130(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x9860
leaq 0xd0(%rsp), %rdi
callq 0x9610
leaq 0x50(%rsp), %rdi
leaq 0xa4a5(%rip), %rsi      # 0x13184
movl $0x60, %edx
callq 0x10c0
movq 0x130(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x9860
leaq 0x50(%rsp), %rdi
callq 0x9610
movq 0x168(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x96d0
movq 0x168(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
leaq 0x2f(%rsp), %rsi
callq 0x9510
movl $0x20, %edi
callq 0x99f0
movq 0xd0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xd8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0xe8(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x188, %rsp            # imm = 0x188
retq
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/crack.cpp
// Function: genauthkey(char const*)
void genauthkey(const char *secret) {
    if(!secret[0]) { 
        printf("you must specify a secret password");
        return;
    }
    
    vector<char> privkey, pubkey;
    c_genprivkey(secret, privkey, pubkey);
    
    printf("private key: %s\n", privkey.getbuf());
    printf("public key: %s\n", pubkey.getbuf());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x9036
leaq 0x510c(%rip), %rdi      # 0xe136
movb $0x0, %al
callq 0x1030
jmp 0x90c0
leaq 0x30(%rsp), %rdi
callq 0x9b30
leaq 0x20(%rsp), %rdi
callq 0x9b30
jmp 0x904c
movq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x8e80
jmp 0x9062
leaq 0x30(%rsp), %rdi
callq 0x9b50
movq %rax, 0x8(%rsp)
jmp 0x9073
movq 0x8(%rsp), %rsi
leaq 0x50da(%rip), %rdi      # 0xe159
xorl %eax, %eax
callq 0x1030
jmp 0x9088
leaq 0x20(%rsp), %rdi
callq 0x9b50
movq %rax, (%rsp)
jmp 0x9098
movq (%rsp), %rsi
leaq 0x50c7(%rip), %rdi      # 0xe16a
xorl %eax, %eax
callq 0x1030
jmp 0x90ac
leaq 0x20(%rsp), %rdi
callq 0x9b60
leaq 0x30(%rsp), %rdi
callq 0x9b60
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x90ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x9b60
leaq 0x30(%rsp), %rdi
callq 0x9b60
movq 0x18(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/crack.cpp
// Function: measure(int, char const*)
tfloat measure(int times, const char* pass) {
    tfloat t0, t1;

    t0 = nanotime();    
    for (int i = 0; i < times; i++)
        genauthkey(pass); 
    t1 = nanotime();

    return t1 - t0;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
callq 0x8e40
fstpt 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x914f
movq 0x38(%rsp), %rdi
callq 0x9010
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x912e
callq 0x8e40
fstpt 0x10(%rsp)
fldt 0x10(%rsp)
fldt 0x20(%rsp)
fsubrp %st, %st(1)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: koraa[P]sbcrack/crack.cpp
// Function: main
int main(const int argc, const char** argv){ 
    const char* pass = argv[1];
    int  times = 1;
    if (argc > 1)
      times = atoi(argv[2]);

    genauthkey(pass);
    //printf("Seconds needed to generate %i: %Lf\n", times, measure(times, pass));
    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
cmpl $0x1, 0x20(%rsp)
jle 0x91b4
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1120
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9010
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<12>::printdigits(vector<char>&) const
void printdigits(vector<char> &buf) const
    {
        loopi(len)
        {
            digit d = digits[len-i-1];
            loopj(BI_DIGIT_BITS/4)
            {
                uint shift = BI_DIGIT_BITS - (j+1)*4;
                int val = (d >> shift) & 0xF;
                if(val < 10) buf.add('0' + val);
                else buf.add('a' + val - 10);
            }
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl (%rcx), %eax
jge 0x9503
movq 0x8(%rsp), %rax
movl (%rax), %ecx
subl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw 0x4(%rax,%rcx,2), %ax
movw %ax, 0x22(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x94f1
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
shll $0x2, %ecx
movl $0x10, %eax
subl %ecx, %eax
movl %eax, 0x18(%rsp)
movzwl 0x22(%rsp), %eax
movl 0x18(%rsp), %ecx
sarl %cl, %eax
andl $0xf, %eax
movl %eax, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jge 0x94c5
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x30, %eax
movb %al, 0x13(%rsp)
leaq 0x13(%rsp), %rsi
callq 0x9510
jmp 0x94e2
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x61, %eax
subl $0xa, %eax
movb %al, 0x12(%rsp)
leaq 0x12(%rsp), %rsi
callq 0x9510
jmp 0x94e4
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9474
jmp 0x94f3
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9440
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: ecjacobian::normalize()
void normalize()
    {
        if(z.iszero() || z.isone()) return;
        gfield tmp;
        z.invert();
        tmp.square(z);
        x.mul(tmp);
        y.mul(tmp).mul(z);
        z = bigint<1>(1);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
callq 0x9cc0
testb $0x1, %al
jne 0x9642
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x9ce0
testb $0x1, %al
jne 0x9642
jmp 0x9644
jmp 0x96be
leaq 0x10(%rsp), %rdi
callq 0x9d20
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x9d30
movq (%rsp), %rsi
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0x9d50
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9d80
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x10(%rsp), %rsi
callq 0x9d80
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x40, %rsi
callq 0x9d80
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9bc0
movq (%rsp), %rdi
addq $0x40, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9db0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: ecjacobian::parse(char const*)
void parse(const char *s)
    {
        bool ybit = *s++ == '-';
        x.parse(s);
        calcy(ybit);
        z = bigint<1>(1);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rsi
callq 0x9760
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xadc0
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0x9bc0
movq (%rsp), %rdi
addq $0x40, %rdi
leaq 0xc(%rsp), %rsi
callq 0x9db0
addq $0x28, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bool bigint<13>::operator<<13>(bigint<13> const&) const
bool operator<(const bigint<Y_DIGITS> &y) const
    {
        if(len<y.len) return true;
        if(len>y.len) return false;
        for(int i = len-1; i>=0; i--)
        {
            if(digits[i]<y.digits[i]) return true;
            if(digits[i]>y.digits[i]) return false;
        }
        return false;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa309
movb $0x1, -0x1(%rsp)
jmp 0xa39b
movq -0x28(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xa320
movb $0x0, -0x1(%rsp)
jmp 0xa39b
movq -0x28(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0xa396
movq -0x28(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movzwl 0x4(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jge 0xa35e
movb $0x1, -0x1(%rsp)
jmp 0xa39b
movq -0x28(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movzwl 0x4(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jle 0xa387
movb $0x0, -0x1(%rsp)
jmp 0xa39b
jmp 0xa389
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xa32e
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<13>& bigint<13>::sub<13, 13>(bigint<13> const&, bigint<13> const&)
bigint &sub(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        ASSERT(x >= y);
        dbldigit borrow = 0;
        int i;
        for(i = 0; i < y.len || borrow; i++)
        {
             borrow = (1<<BI_DIGIT_BITS) + (dbldigit)x.digits[i] - (i<y.len ? (dbldigit)y.digits[i] : 0) - borrow;
             digits[i] = (digit)borrow;
             borrow = (borrow>>BI_DIGIT_BITS)^1;
        }
        if(i < x.len && this != &x) memcpy(&digits[i], &x.digits[i], (x.len - i)*sizeof(digit));
        len = x.len;
        shrink();
        return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xa280
testb $0x1, %al
jne 0xa3e2
jmp 0xa3e4
jmp 0xa3e4
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rdx
movb $0x1, %al
cmpl (%rdx), %ecx
movb %al, 0xf(%rsp)
jl 0xa413
cmpl $0x0, 0x1c(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa420
jmp 0xa4a8
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa45a
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movl %eax, 0x4(%rsp)
jmp 0xa462
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0xa462
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %edx
subl %edx, %ecx
subl 0x1c(%rsp), %ecx
movl %ecx, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movw %cx, %dx
movslq 0x18(%rsp), %rcx
movw %dx, 0x4(%rax,%rcx,2)
movl 0x1c(%rsp), %eax
shrl $0x10, %eax
xorl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xa3f4
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa4ff
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0xa4ff
movq 0x10(%rsp), %rdi
addq $0x4, %rdi
movslq 0x18(%rsp), %rax
shlq %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
addq $0x4, %rsi
movslq 0x18(%rsp), %rax
shlq %rax
addq %rax, %rsi
movq 0x28(%rsp), %rax
movl (%rax), %eax
subl 0x18(%rsp), %eax
movslq %eax, %rdx
shlq %rdx
callq 0x10c0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
callq 0x9a20
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<13>& bigint<13>::rshift<13>(bigint<13> const&, int)
bigint &rshift(const bigint<X_DIGITS> &x, int n)
    {
        if(!len || !n) return *this;
        int dig = (n-1)/BI_DIGIT_BITS;
        n = ((n-1) % BI_DIGIT_BITS)+1;
        digit carry = digit(x.digits[dig]>>n);
        loopi(len-dig-1)
        {
            digit tmp = x.digits[i+dig+1];
            digits[i] = digit((tmp<<(BI_DIGIT_BITS-n)) | carry);
            carry = digit(tmp>>n);
        }
        digits[len-dig-1] = carry;
        len -= dig + (n>>BI_DIGIT_BITS);
        shrink();
        return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, (%rax)
je 0xa547
cmpl $0x0, 0x1c(%rsp)
jne 0xa555
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xa653
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl $0x10, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movl 0x1c(%rsp), %ecx
sarl %cl, %eax
movw %ax, 0x16(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rsp), %rcx
movl 0x10(%rsp), %eax
movl (%rcx), %ecx
subl 0x18(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa619
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0x10(%rsp), %edx
addl 0x18(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movw 0x4(%rcx,%rdx,2), %cx
movw %cx, 0xe(%rsp)
movzwl 0xe(%rsp), %edx
movl $0x10, %ecx
subl 0x1c(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
movzwl 0x16(%rsp), %edx
orl %edx, %ecx
movw %cx, %dx
movslq 0x10(%rsp), %rcx
movw %dx, 0x4(%rax,%rcx,2)
movzwl 0xe(%rsp), %eax
movl 0x1c(%rsp), %ecx
sarl %cl, %eax
movw %ax, 0x16(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xa5a0
movq (%rsp), %rdi
movw 0x16(%rsp), %cx
movl (%rdi), %eax
subl 0x18(%rsp), %eax
subl $0x1, %eax
cltq
movw %cx, 0x4(%rdi,%rax,2)
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %eax
sarl $0x10, %eax
addl %eax, %ecx
movl (%rdi), %eax
subl %ecx, %eax
movl %eax, (%rdi)
callq 0x9a20
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<13>& bigint<13>::add<13, 13>(bigint<13> const&, bigint<13> const&)
bigint &add(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        dbldigit carry = 0;
        int maxlen = max(x.len, y.len), i;
        for(i = 0; i < y.len || carry; i++)
        {
             carry += (i < x.len ? (dbldigit)x.digits[i] : 0) + (i < y.len ? (dbldigit)y.digits[i] : 0);
             digits[i] = (digit)carry;
             carry >>= BI_DIGIT_BITS;
        }
        if(i < x.len && this != &x) memcpy(&digits[i], &x.digits[i], (x.len - i)*sizeof(digit));
        len = max(i, maxlen);
        return *this;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %edi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0x91d0
movl %eax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movq 0x30(%rsp), %rdx
movb $0x1, %al
cmpl (%rdx), %ecx
movb %al, 0x17(%rsp)
jl 0xa6c3
cmpl $0x0, 0x2c(%rsp)
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xa6d0
jmp 0xa76f
movl 0x24(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa6f2
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movl %eax, 0x10(%rsp)
jmp 0xa6fa
xorl %eax, %eax
movl %eax, 0x10(%rsp)
jmp 0xa6fa
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa724
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movzwl 0x4(%rax,%rcx,2), %eax
movl %eax, 0x8(%rsp)
jmp 0xa72c
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0xa72c
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %edx
addl %edx, %ecx
addl 0x2c(%rsp), %ecx
movl %ecx, 0x2c(%rsp)
movl 0x2c(%rsp), %ecx
movw %cx, %dx
movslq 0x24(%rsp), %rcx
movw %dx, 0x4(%rax,%rcx,2)
movl 0x2c(%rsp), %eax
shrl $0x10, %eax
movl %eax, 0x2c(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa6a4
movl 0x24(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa7c6
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0xa7c6
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movslq 0x24(%rsp), %rax
shlq %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
addq $0x4, %rsi
movslq 0x24(%rsp), %rax
shlq %rax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl (%rax), %eax
subl 0x24(%rsp), %eax
movslq %eax, %rdx
shlq %rdx
callq 0x10c0
movl 0x24(%rsp), %edi
movl 0x28(%rsp), %esi
callq 0x91d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: gfield& gfield::mul<13, 13>(bigint<13> const&, bigint<13> const&)
gfield &mul(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        bigint<X_DIGITS+Y_DIGITS> result;
        result.mul(x, y);
        reduce(result);
        return *this;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0xa850
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xa860
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa9c0
movq (%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<26>& bigint<26>::mul<13, 13>(bigint<13> const&, bigint<13> const&)
bigint &mul(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        if(!x.len || !y.len) { len = 0; return *this; }
        memset(digits, 0, y.len*sizeof(digit));
        loopi(x.len)
        {
            dbldigit carry = 0;
            loopj(y.len)
            {
                carry += (dbldigit)x.digits[i] * (dbldigit)y.digits[j] + (dbldigit)digits[i+j];
                digits[i+j] = (digit)carry;
                carry >>= BI_DIGIT_BITS;
            }
            digits[i+y.len] = carry;
        }
        len = x.len + y.len;
        shrink();
        return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0xa890
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xa8a4
movq (%rsp), %rax
movl $0x0, (%rax)
movq %rax, 0x30(%rsp)
jmp 0xa9b2
movq (%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rdx
shlq %rdx
xorl %esi, %esi
callq 0x1080
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa990
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa962
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rsp), %rdx
movzwl 0x4(%rcx,%rdx,2), %ecx
movq 0x18(%rsp), %rdx
movslq 0xc(%rsp), %rsi
movzwl 0x4(%rdx,%rsi,2), %edx
imull %edx, %ecx
movl 0x14(%rsp), %edx
addl 0xc(%rsp), %edx
movslq %edx, %rdx
movzwl 0x4(%rax,%rdx,2), %edx
addl %edx, %ecx
addl 0x10(%rsp), %ecx
movl %ecx, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movw %cx, %dx
movl 0x14(%rsp), %ecx
addl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movw %dx, 0x4(%rax,%rcx,2)
movl 0x10(%rsp), %eax
shrl $0x10, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa8e7
movq (%rsp), %rax
movl 0x10(%rsp), %ecx
movw %cx, %dx
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rsi
addl (%rsi), %ecx
movslq %ecx, %rcx
movw %dx, 0x4(%rax,%rcx,2)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa8c6
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
addl (%rcx), %eax
movl %eax, (%rdi)
callq 0xacc0
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: ecjacobian::calcy(bool)
bool calcy(bool ybit)
    {
        gfield y2, tmp;
        y2.square(x).mul(x).sub(tmp.add(x, x).add(x)).add(B);
        if(!y.sqrt(y2)) { y.zero(); return false; }
        if(y.hasbit(0) != ybit) y.neg();
        return true;
    }

// Assembly:
subq $0x68, %rsp
movb %sil, %al
movq %rdi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x34(%rsp), %rdi
callq 0x9d20
leaq 0x14(%rsp), %rdi
callq 0x9d20
movq 0x8(%rsp), %rsi
leaq 0x34(%rsp), %rdi
callq 0x9d50
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x9d80
movq 0x8(%rsp), %rdx
movq %rax, (%rsp)
leaq 0x14(%rsp), %rdi
movq %rdx, %rsi
callq 0xad50
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xad20
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xaec0
movq %rax, %rdi
leaq 0x831f(%rip), %rsi      # 0x13164
callq 0xad20
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x34(%rsp), %rsi
callq 0xaef0
testb $0x1, %al
jne 0xae76
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xb080
movb $0x0, 0x67(%rsp)
jmp 0xaeac
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0xa1a0
andb $0x1, %al
movzbl %al, %eax
movb 0x57(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xaea7
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xb0a0
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: gfield::sqrt(gfield const&)
bool sqrt(const gfield &x)
    {
        if(!x.len) { len = 0; return true; }
#if GF_BITS==224
#error Unsupported GF
#else
        ASSERT((P.digits[0]%4)==3);
        static const gfint Padd1div4(gfint(P).add(bigint<1>(1)).rshift(2));
        switch(legendre(x))
        {
            case 0: len = 0; return true;
            case -1: return false;
            default: pow(x, Padd1div4); return true;
        }
#endif
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xaf27
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movb $0x1, 0x77(%rsp)
jmp 0xb061
movzwl 0x821a(%rip), %eax      # 0x13148
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x3, %edx
jne 0xaf3d
jmp 0xaf3d
cmpb $0x0, 0x82c4(%rip)      # 0x13208
jne 0xaff0
leaq 0x82b7(%rip), %rdi      # 0x13208
callq 0x1150
cmpl $0x0, %eax
je 0xaff0
movups 0x81ec(%rip), %xmm0     # 0x13152
movups %xmm0, 0x4e(%rsp)
movups 0x81d2(%rip), %xmm0     # 0x13144
movaps %xmm0, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x9bc0
jmp 0xaf88
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xb150
movq %rax, 0x18(%rsp)
jmp 0xaf9e
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0xa220
movq %rax, 0x10(%rsp)
jmp 0xafb4
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8221(%rip)      # 0x131e4
movq 0x8(%rax), %rcx
movq %rcx, 0x821e(%rip)      # 0x131ec
movq 0x10(%rax), %rcx
movq %rcx, 0x821b(%rip)      # 0x131f4
movq 0x18(%rax), %rax
movq %rax, 0x8218(%rip)      # 0x131fc
leaq 0x821d(%rip), %rdi      # 0x13208
callq 0x10b0
movq 0x60(%rsp), %rdi
callq 0xb180
movl %eax, %ecx
movl %ecx, 0xc(%rsp)
subl $-0x1, %eax
je 0xb03f
jmp 0xb007
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0xb02d
jmp 0xb046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x81e2(%rip), %rdi      # 0x13208
callq 0x10a0
jmp 0xb06c
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movb $0x1, 0x77(%rsp)
jmp 0xb061
movb $0x0, 0x77(%rsp)
jmp 0xb061
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x818d(%rip), %rdx      # 0x131e4
callq 0xb2d0
movb $0x1, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: gfield& gfield::sub<13, 13>(bigint<13> const&, bigint<13> const&)
gfield &sub(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        if(x < y)
        {
            gfint tmp; /* necessary if this==&y, using this instead would clobber y */
            tmp.add(x, P);
            gfint::sub(tmp, y);
        }
        else gfint::sub(x, y);
        return *this;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xa2e0
testb $0x1, %al
jne 0xb0f2
jmp 0xb128
leaq 0x10(%rsp), %rdi
callq 0x9750
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x8037(%rip), %rdx      # 0x13144
callq 0xa660
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0xa3b0
jmp 0xb13c
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xa3b0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: int gfield::legendre<13>(bigint<13> const&)
static int legendre(const bigint<X_DIGITS> &x)
    {
        static const gfint Psub1div2(gfint(P).sub(bigint<1>(1)).rshift(1));
        gfield L;
        L.pow(x, Psub1div2);
        if(!L.len) return 0;
        if(L.len==1) return 1;
        return -1;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
cmpb $0x0, 0x809d(%rip)      # 0x13230
jne 0xb23f
leaq 0x8090(%rip), %rdi      # 0x13230
callq 0x1150
cmpl $0x0, %eax
je 0xb23f
movups 0x7f9d(%rip), %xmm0     # 0x13152
movups %xmm0, 0x5e(%rsp)
movups 0x7f83(%rip), %xmm0     # 0x13144
movaps %xmm0, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x9bc0
jmp 0xb1d7
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb570
movq %rax, 0x10(%rsp)
jmp 0xb1ed
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xa220
movq %rax, 0x8(%rsp)
jmp 0xb203
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x7ffe(%rip)      # 0x13210
movq 0x8(%rax), %rcx
movq %rcx, 0x7ffb(%rip)      # 0x13218
movq 0x10(%rax), %rcx
movq %rcx, 0x7ff8(%rip)      # 0x13220
movq 0x18(%rax), %rax
movq %rax, 0x7ff5(%rip)      # 0x13228
leaq 0x7ff6(%rip), %rdi      # 0x13230
callq 0x10b0
leaq 0x1c(%rsp), %rdi
callq 0x9d20
movq 0x78(%rsp), %rsi
leaq 0x1c(%rsp), %rdi
leaq 0x7fb6(%rip), %rdx      # 0x13210
callq 0xb2d0
cmpl $0x0, 0x1c(%rsp)
jne 0xb28f
movl $0x0, 0x84(%rsp)
jmp 0xb2ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x7fa8(%rip), %rdi      # 0x13230
callq 0x10a0
jmp 0xb2bd
cmpl $0x1, 0x1c(%rsp)
jne 0xb2a3
movl $0x1, 0x84(%rsp)
jmp 0xb2ae
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x1140
nopw (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: gfield& gfield::pow<13, 13>(bigint<13> const&, bigint<13> const&)
gfield &pow(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
    {
        gfield a(x);
        if(y.hasbit(0)) *this = a;
        else
        {
            len = 1;
            digits[0] = 1;
            if(!y.len) return *this;
        }
        for(int i = 1, j = y.numbits(); i < j; i++)
        {
            a.square();
            if(y.hasbit(i)) mul(a);
        }
        return *this;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xb810
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xa1a0
testb $0x1, %al
jne 0xb30e
jmp 0xb33f
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x18(%rax)
movw 0x34(%rsp), %cx
movw %cx, 0x1c(%rax)
jmp 0xb368
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movw $0x1, 0x4(%rax)
movq 0x38(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xb366
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xb3ce
jmp 0xb368
movl $0x1, 0x14(%rsp)
movq 0x38(%rsp), %rdi
callq 0xb850
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0xb3c4
leaq 0x18(%rsp), %rdi
callq 0xb8e0
movq 0x38(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xa1a0
testb $0x1, %al
jne 0xb3a6
jmp 0xb3b5
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9d80
jmp 0xb3b7
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xb37e
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<13>::numbits() const
int numbits() const
    {
        if(!len) return 0;
        int bits = len*BI_DIGIT_BITS;
        digit last = digits[len-1], mask = 1<<(BI_DIGIT_BITS-1);
        while(mask)
        {
            if(last&mask) return bits;
            bits--;
            mask >>= 1;
        }
        return 0;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, (%rax)
jne 0xb86e
movl $0x0, -0x4(%rsp)
jmp 0xb8d9
movq -0x20(%rsp), %rax
movl (%rax), %ecx
shll $0x4, %ecx
movl %ecx, -0x14(%rsp)
movl (%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw 0x4(%rax,%rcx,2), %ax
movw %ax, -0x16(%rsp)
movw $0x8000, -0x18(%rsp)    # imm = 0x8000
cmpw $0x0, -0x18(%rsp)
je 0xb8d1
movzwl -0x16(%rsp), %eax
movzwl -0x18(%rsp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb8b8
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xb8d9
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
movzwl -0x18(%rsp), %eax
sarl %eax
movw %ax, -0x18(%rsp)
jmp 0xb895
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: bigint<13>::parsedigits(unsigned short*, int, char const*)
static int parsedigits(ushort *digits, int maxlen, const char *s)
    {
        int slen = 0;
        while(isxdigit(s[slen])) slen++;
        int len = (slen+2*sizeof(ushort)-1)/(2*sizeof(ushort));
        if(len>maxlen) return 0;
        memset(digits, 0, len*sizeof(ushort));
        loopi(slen)
        {
            int c = s[slen-i-1];
            if(isalpha(c)) c = toupper(c) - 'A' + 10;
            else if(isdigit(c)) c -= '0';
            else return 0;
            digits[i/(2*sizeof(ushort))] |= c<<(4*(i%(2*sizeof(ushort))));
        }
        return len;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1040
cmpl $0x0, %eax
je 0xbaaf
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xba8a
movslq 0x14(%rsp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jle 0xbadb
movl $0x0, 0x34(%rsp)
jmp 0xbbaf
movq 0x28(%rsp), %rdi
movslq 0x10(%rsp), %rdx
shlq %rdx
xorl %esi, %esi
callq 0x1080
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xbba7
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
subl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x1130
cmpl $0x0, %eax
je 0xbb43
movl 0x8(%rsp), %edi
callq 0x1160
subl $0x41, %eax
addl $0xa, %eax
movl %eax, 0x8(%rsp)
jmp 0xbb6a
movl 0x8(%rsp), %edi
callq 0x10d0
cmpl $0x0, %eax
je 0xbb5e
movl 0x8(%rsp), %eax
subl $0x30, %eax
movl %eax, 0x8(%rsp)
jmp 0xbb68
movl $0x0, 0x34(%rsp)
jmp 0xbbaf
jmp 0xbb6a
movl 0x8(%rsp), %esi
movslq 0xc(%rsp), %rax
andq $0x3, %rax
shlq $0x2, %rax
movl %eax, %ecx
shll %cl, %esi
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
shrq $0x2, %rcx
movzwl (%rax,%rcx,2), %edx
orl %esi, %edx
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xbaf7
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: void ecjacobian::mul<12>(ecjacobian const&, bigint<12>)
void mul(const ecjacobian &p, const bigint<Q_DIGITS> q)
    {
        *this = origin;
        for(int i = q.numbits()-1; i >= 0; i--)
        {
            mul2();
            if(q.hasbit(i)) add(p);
        }
    }

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x74fc(%rip), %rsi      # 0x130e4
movl $0x60, %edx
callq 0x10c0
movq 0x8(%rsp), %rdi
callq 0xbc50
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0xbc44
movq (%rsp), %rdi
callq 0xbce0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xbeb0
testb $0x1, %al
jne 0xbc27
jmp 0xbc35
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbf30
jmp 0xbc37
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xbc03
addq $0x28, %rsp
retq
nopl (%rax)
// File: koraa[P]sbcrack/cube/crypto.cpp
// Function: ecjacobian::mul2()
void mul2()
    {
        if(z.iszero()) return;
        else if(y.iszero()) { *this = origin; return; }
        gfield a, b, c, d;
        d.sub(x, c.square(z));
        d.mul(c.add(x));
        c.mul2(d).add(d);
        z.mul(y).add(z);
        a.square(y);
        b.mul2(a);
        d.mul2(x).mul(b);
        x.square(c).sub(d).sub(d);
        a.square(b).add(a);
        y.sub(d, x).mul(c).sub(a);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x40, %rdi
callq 0x9cc0
testb $0x1, %al
jne 0xbd0b
jmp 0xbd10
jmp 0xbe9f
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9cc0
testb $0x1, %al
jne 0xbd24
jmp 0xbd3f
movq 0x8(%rsp), %rdi
leaq 0x73b4(%rip), %rsi      # 0x130e4
movl $0x60, %edx
callq 0x10c0
jmp 0xbe9f
jmp 0xbd41
leaq 0x70(%rsp), %rdi
callq 0x9d20
leaq 0x50(%rsp), %rdi
callq 0x9d20
leaq 0x30(%rsp), %rdi
callq 0x9d20
leaq 0x10(%rsp), %rdi
callq 0x9d20
movq 0x8(%rsp), %rsi
addq $0x40, %rsi
leaq 0x30(%rsp), %rdi
callq 0x9d50
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x10(%rsp), %rdi
callq 0xb0c0
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xad20
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x9d80
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc2d0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xad20
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x20, %rsi
callq 0x9d80
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x40, %rsi
callq 0xad20
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x70(%rsp), %rdi
callq 0x9d50
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xc2d0
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xc2d0
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x9d80
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9d50
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xaec0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xaec0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9d50
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0xad20
movq 0x8(%rsp), %rdx
movq %rdx, %rdi
addq $0x20, %rdi
leaq 0x10(%rsp), %rsi
callq 0xb0c0
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x9d80
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0xaec0
addq $0x98, %rsp
retq
nopw (%rax,%rax)
// File: koraa[P]sbcrack/cube/geom.cpp
// Function: glmatrixf::determinant() const
float glmatrixf::determinant() const
{
    float a1 = v[0], a2 = v[1], a3 = v[2], a4 = v[3],
          b1 = v[4], b2 = v[5], b3 = v[6], b4 = v[7],
          c1 = v[8], c2 = v[9], c3 = v[10], c4 = v[11],
          d1 = v[12], d2 = v[13], d3 = v[14], d4 = v[15];

    return a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4)
         - b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4)
         + c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4)
         - d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x6c(%rsp)
movss 0x4(%rax), %xmm0
movss %xmm0, 0x68(%rsp)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x64(%rsp)
movss 0xc(%rax), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x10(%rax), %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x14(%rax), %xmm0
movss %xmm0, 0x58(%rsp)
movss 0x18(%rax), %xmm0
movss %xmm0, 0x54(%rsp)
movss 0x1c(%rax), %xmm0
movss %xmm0, 0x50(%rsp)
movss 0x20(%rax), %xmm0
movss %xmm0, 0x4c(%rsp)
movss 0x24(%rax), %xmm0
movss %xmm0, 0x48(%rsp)
movss 0x28(%rax), %xmm0
movss %xmm0, 0x44(%rsp)
movss 0x2c(%rax), %xmm0
movss %xmm0, 0x40(%rsp)
movss 0x30(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x34(%rax), %xmm0
movss %xmm0, 0x38(%rsp)
movss 0x38(%rax), %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x3c(%rax), %xmm0
movss %xmm0, 0x30(%rsp)
movss 0x6c(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x58(%rsp), %xmm0
movss 0x54(%rsp), %xmm1
movss 0x50(%rsp), %xmm2
movss 0x48(%rsp), %xmm3
movss 0x44(%rsp), %xmm4
movss 0x40(%rsp), %xmm5
movss 0x38(%rsp), %xmm6
movss 0x34(%rsp), %xmm7
movss 0x30(%rsp), %xmm8
movss %xmm8, (%rsp)
callq 0xc6c0
movaps %xmm0, %xmm1
movss 0x14(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x5c(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x68(%rsp), %xmm0
movss 0x64(%rsp), %xmm1
movss 0x60(%rsp), %xmm2
movss 0x48(%rsp), %xmm3
movss 0x44(%rsp), %xmm4
movss 0x40(%rsp), %xmm5
movss 0x38(%rsp), %xmm6
movss 0x34(%rsp), %xmm7
movss 0x30(%rsp), %xmm8
movss %xmm8, (%rsp)
callq 0xc6c0
movss 0x18(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x1c(%rsp), %xmm0
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x68(%rsp), %xmm0
movss 0x64(%rsp), %xmm1
movss 0x60(%rsp), %xmm2
movss 0x58(%rsp), %xmm3
movss 0x54(%rsp), %xmm4
movss 0x50(%rsp), %xmm5
movss 0x38(%rsp), %xmm6
movss 0x34(%rsp), %xmm7
movss 0x30(%rsp), %xmm8
movss %xmm8, (%rsp)
callq 0xc6c0
movss 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x24(%rsp), %xmm0
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x2c(%rsp)
movss 0x3c(%rsp), %xmm0
movss %xmm0, 0x28(%rsp)
movss 0x68(%rsp), %xmm0
movss 0x64(%rsp), %xmm1
movss 0x60(%rsp), %xmm2
movss 0x58(%rsp), %xmm3
movss 0x54(%rsp), %xmm4
movss 0x50(%rsp), %xmm5
movss 0x48(%rsp), %xmm6
movss 0x44(%rsp), %xmm7
movss 0x40(%rsp), %xmm8
movss %xmm8, (%rsp)
callq 0xc6c0
movss 0x28(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x2c(%rsp), %xmm0
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
addq $0x78, %rsp
retq
nop