rind 0.1.12

// generated source. do not edit.
#![allow(non_upper_case_globals, unused_macros, unused_imports)]
use crate::low::macros::*;

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT-0

// ----------------------------------------------------------------------------
// Point doubling on NIST curve P-521 in Jacobian coordinates
//
//    extern void p521_jdouble(uint64_t p3[static 27], const uint64_t p1[static 27]);
//
// Does p3 := 2 * p1 where all points are regarded as Jacobian triples.
// A Jacobian triple (x,y,z) represents affine point (x/z^2,y/z^3).
// It is assumed that all coordinates of the input point are fully
// reduced mod p_521 and that the z coordinate is not zero.
//
// Standard x86-64 ABI: RDI = p3, RSI = p1
// Microsoft x64 ABI:   RCX = p3, RDX = p1
// ----------------------------------------------------------------------------

// Size of individual field elements

macro_rules! NUMSIZE {
    () => {
        "72"
    };
}

// Stable homes for input arguments during main code sequence
// This is actually where they come in anyway and they stay there.

macro_rules! input_z {
    () => {
        "rdi"
    };
}
macro_rules! input_x {
    () => {
        "rsi"
    };
}

// Pointer-offset pairs for inputs and outputs

macro_rules! x_1 { () => { Q!(input_x!() "+ 0") } }
macro_rules! y_1 { () => { Q!(input_x!() "+ " NUMSIZE!()) } }
macro_rules! z_1 { () => { Q!(input_x!() "+ (2 * " NUMSIZE!() ")") } }

macro_rules! x_3 { () => { Q!(input_z!() "+ 0") } }
macro_rules! y_3 { () => { Q!(input_z!() "+ " NUMSIZE!()) } }
macro_rules! z_3 { () => { Q!(input_z!() "+ (2 * " NUMSIZE!() ")") } }

// Pointer-offset pairs for temporaries, with some aliasing
// The tmp field is internal storage for field mul and sqr.
// NSPACE is the total stack needed for these temporaries

macro_rules! z2 { () => { Q!("rsp + (" NUMSIZE!() "* 0)") } }
macro_rules! y2 { () => { Q!("rsp + (" NUMSIZE!() "* 1)") } }
macro_rules! x2p { () => { Q!("rsp + (" NUMSIZE!() "* 2)") } }
macro_rules! xy2 { () => { Q!("rsp + (" NUMSIZE!() "* 3)") } }

macro_rules! y4 { () => { Q!("rsp + (" NUMSIZE!() "* 4)") } }
macro_rules! t2 { () => { Q!("rsp + (" NUMSIZE!() "* 4)") } }

macro_rules! dx2 { () => { Q!("rsp + (" NUMSIZE!() "* 5)") } }
macro_rules! t1 { () => { Q!("rsp + (" NUMSIZE!() "* 5)") } }

macro_rules! d { () => { Q!("rsp + (" NUMSIZE!() "* 6)") } }
macro_rules! x4p { () => { Q!("rsp + (" NUMSIZE!() "* 6)") } }

macro_rules! tmp { () => { Q!("rsp + (" NUMSIZE!() "* 7)") } }

macro_rules! NSPACE {
    () => {
        "568"
    };
}

// Corresponds exactly to bignum_mul_p521

macro_rules! mul_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "xor ecx, ecx;\n"
        "mov rdx, [" $P2 "];\n"
        "mulx r9, r8, [" $P1 "];\n"
        "mov [rsp + 504], r8;\n"
        "mulx r10, rbx, [" $P1 "+ 0x8];\n"
        "adc r9, rbx;\n"
        "mulx r11, rbx, [" $P1 "+ 0x10];\n"
        "adc r10, rbx;\n"
        "mulx r12, rbx, [" $P1 "+ 0x18];\n"
        "adc r11, rbx;\n"
        "mulx r13, rbx, [" $P1 "+ 0x20];\n"
        "adc r12, rbx;\n"
        "mulx r14, rbx, [" $P1 "+ 0x28];\n"
        "adc r13, rbx;\n"
        "mulx r15, rbx, [" $P1 "+ 0x30];\n"
        "adc r14, rbx;\n"
        "mulx r8, rbx, [" $P1 "+ 0x38];\n"
        "adc r15, rbx;\n"
        "adc r8, rcx;\n"
        "mov rdx, [" $P2 "+ 0x8];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mov [rsp + 512], r9;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx r9, rax, [" $P1 "+ 0x38];\n"
        "adcx r8, rax;\n"
        "adox r9, rcx;\n"
        "adc r9, rcx;\n"
        "mov rdx, [" $P2 "+ 0x10];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mov [rsp + 520], r10;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx r10, rax, [" $P1 "+ 0x38];\n"
        "adcx r9, rax;\n"
        "adox r10, rcx;\n"
        "adc r10, rcx;\n"
        "mov rdx, [" $P2 "+ 0x18];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mov [rsp + 528], r11;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx r11, rax, [" $P1 "+ 0x38];\n"
        "adcx r10, rax;\n"
        "adox r11, rcx;\n"
        "adc r11, rcx;\n"
        "mov rdx, [" $P2 "+ 0x20];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mov [rsp + 536], r12;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx r12, rax, [" $P1 "+ 0x38];\n"
        "adcx r11, rax;\n"
        "adox r12, rcx;\n"
        "adc r12, rcx;\n"
        "mov rdx, [" $P2 "+ 0x28];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mov [rsp + 544], r13;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx r13, rax, [" $P1 "+ 0x38];\n"
        "adcx r12, rax;\n"
        "adox r13, rcx;\n"
        "adc r13, rcx;\n"
        "mov rdx, [" $P2 "+ 0x30];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mov [rsp + 552], r14;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx r14, rax, [" $P1 "+ 0x38];\n"
        "adcx r13, rax;\n"
        "adox r14, rcx;\n"
        "adc r14, rcx;\n"
        "mov rdx, [" $P2 "+ 0x38];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mov [rsp + 560], r15;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx r15, rax, [" $P1 "+ 0x38];\n"
        "adcx r14, rax;\n"
        "adox r15, rcx;\n"
        "adc r15, rcx;\n"
        "mov rdx, [" $P1 "+ 0x40];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P2 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x8];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x18];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x28];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x38];\n"
        "adcx r15, rax;\n"
        "adox rbx, rcx;\n"
        "adc rcx, rbx;\n"
        "mov rdx, [" $P2 "+ 0x40];\n"
        "xor eax, eax;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x38];\n"
        "adcx r15, rax;\n"
        "adox rcx, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x40];\n"
        "adc rcx, rax;\n"
        "mov rax, r8;\n"
        "and rax, 0x1ff;\n"
        "shrd r8, r9, 0x9;\n"
        "shrd r9, r10, 0x9;\n"
        "shrd r10, r11, 0x9;\n"
        "shrd r11, r12, 0x9;\n"
        "shrd r12, r13, 0x9;\n"
        "shrd r13, r14, 0x9;\n"
        "shrd r14, r15, 0x9;\n"
        "shrd r15, rcx, 0x9;\n"
        "shr rcx, 0x9;\n"
        "add rcx, rax;\n"
        "stc;\n"
        "adc r8, [rsp + 504];\n"
        "adc r9, [rsp + 512];\n"
        "adc r10, [rsp + 520];\n"
        "adc r11, [rsp + 528];\n"
        "adc r12, [rsp + 536];\n"
        "adc r13, [rsp + 544];\n"
        "adc r14, [rsp + 552];\n"
        "adc r15, [rsp + 560];\n"
        "adc rcx, 0xfffffffffffffe00;\n"
        "cmc;\n"
        "sbb r8, 0x0;\n"
        "mov [" $P0 "], r8;\n"
        "sbb r9, 0x0;\n"
        "mov [" $P0 "+ 0x8], r9;\n"
        "sbb r10, 0x0;\n"
        "mov [" $P0 "+ 0x10], r10;\n"
        "sbb r11, 0x0;\n"
        "mov [" $P0 "+ 0x18], r11;\n"
        "sbb r12, 0x0;\n"
        "mov [" $P0 "+ 0x20], r12;\n"
        "sbb r13, 0x0;\n"
        "mov [" $P0 "+ 0x28], r13;\n"
        "sbb r14, 0x0;\n"
        "mov [" $P0 "+ 0x30], r14;\n"
        "sbb r15, 0x0;\n"
        "mov [" $P0 "+ 0x38], r15;\n"
        "sbb rcx, 0x0;\n"
        "and rcx, 0x1ff;\n"
        "mov [" $P0 "+ 0x40], rcx"
    )}
}

// Corresponds exactly to bignum_sqr_p521

macro_rules! sqr_p521 {
    ($P0:expr, $P1:expr) => { Q!(
        "xor ecx, ecx;\n"
        "mov rdx, [" $P1 "];\n"
        "mulx rax, r9, [" $P1 "+ 0x8];\n"
        "mov [rsp + 512], r9;\n"
        "mulx rbx, r10, [" $P1 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "mov [rsp + 520], r10;\n"
        "mulx rax, r11, [" $P1 "+ 0x18];\n"
        "adcx r11, rbx;\n"
        "mulx rbx, r12, [" $P1 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "mulx rax, r13, [" $P1 "+ 0x28];\n"
        "adcx r13, rbx;\n"
        "mulx rbx, r14, [" $P1 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "mulx r8, r15, [" $P1 "+ 0x38];\n"
        "adcx r15, rbx;\n"
        "adcx r8, rcx;\n"
        "xor ecx, ecx;\n"
        "mov rdx, [" $P1 "+ 0x8];\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mov [rsp + 528], r11;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mov [rsp + 536], r12;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx r9, rax, [" $P1 "+ 0x38];\n"
        "adcx r8, rax;\n"
        "adox r9, rcx;\n"
        "mov rdx, [" $P1 "+ 0x20];\n"
        "mulx r10, rax, [" $P1 "+ 0x28];\n"
        "adcx r9, rax;\n"
        "adox r10, rcx;\n"
        "adcx r10, rcx;\n"
        "xor ecx, ecx;\n"
        "mov rdx, [" $P1 "+ 0x10];\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mov [rsp + 544], r13;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mov [rsp + 552], r14;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x38];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mov rdx, [" $P1 "+ 0x30];\n"
        "mulx r11, rax, [" $P1 "+ 0x20];\n"
        "adcx r10, rax;\n"
        "adox r11, rcx;\n"
        "mulx r12, rax, [" $P1 "+ 0x28];\n"
        "adcx r11, rax;\n"
        "adox r12, rcx;\n"
        "adcx r12, rcx;\n"
        "xor ecx, ecx;\n"
        "mov rdx, [" $P1 "+ 0x18];\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mov [rsp + 560], r15;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x38];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mov rdx, [" $P1 "+ 0x38];\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx r13, rax, [" $P1 "+ 0x28];\n"
        "adcx r12, rax;\n"
        "adox r13, rcx;\n"
        "mulx r14, rax, [" $P1 "+ 0x30];\n"
        "adcx r13, rax;\n"
        "adox r14, rcx;\n"
        "adcx r14, rcx;\n"
        "xor ecx, ecx;\n"
        "mov rdx, [" $P1 "];\n"
        "mulx rbx, rax, rdx;\n"
        "mov [rsp + 504], rax;\n"
        "mov rax, [rsp + 512];\n"
        "adcx rax, rax;\n"
        "adox rax, rbx;\n"
        "mov [rsp + 512], rax;\n"
        "mov rax, [rsp + 520];\n"
        "mov rdx, [" $P1 "+ 0x8];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx rax, rax;\n"
        "adox rax, rdx;\n"
        "mov [rsp + 520], rax;\n"
        "mov rax, [rsp + 528];\n"
        "adcx rax, rax;\n"
        "adox rax, rbx;\n"
        "mov [rsp + 528], rax;\n"
        "mov rax, [rsp + 536];\n"
        "mov rdx, [" $P1 "+ 0x10];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx rax, rax;\n"
        "adox rax, rdx;\n"
        "mov [rsp + 536], rax;\n"
        "mov rax, [rsp + 544];\n"
        "adcx rax, rax;\n"
        "adox rax, rbx;\n"
        "mov [rsp + 544], rax;\n"
        "mov rax, [rsp + 552];\n"
        "mov rdx, [" $P1 "+ 0x18];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx rax, rax;\n"
        "adox rax, rdx;\n"
        "mov [rsp + 552], rax;\n"
        "mov rax, [rsp + 560];\n"
        "adcx rax, rax;\n"
        "adox rax, rbx;\n"
        "mov [rsp + 560], rax;\n"
        "mov rdx, [" $P1 "+ 0x20];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx r8, r8;\n"
        "adox r8, rdx;\n"
        "adcx r9, r9;\n"
        "adox r9, rbx;\n"
        "mov rdx, [" $P1 "+ 0x28];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx r10, r10;\n"
        "adox r10, rdx;\n"
        "adcx r11, r11;\n"
        "adox r11, rbx;\n"
        "mov rdx, [" $P1 "+ 0x30];\n"
        "mulx rbx, rdx, rdx;\n"
        "adcx r12, r12;\n"
        "adox r12, rdx;\n"
        "adcx r13, r13;\n"
        "adox r13, rbx;\n"
        "mov rdx, [" $P1 "+ 0x38];\n"
        "mulx r15, rdx, rdx;\n"
        "adcx r14, r14;\n"
        "adox r14, rdx;\n"
        "adcx r15, rcx;\n"
        "adox r15, rcx;\n"
        "mov rdx, [" $P1 "+ 0x40];\n"
        "mov rcx, rdx;\n"
        "imul rcx, rcx;\n"
        "add rdx, rdx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x38];\n"
        "adcx r15, rax;\n"
        "adox rcx, rbx;\n"
        "adc rcx, 0x0;\n"
        "mov rax, r8;\n"
        "and rax, 0x1ff;\n"
        "shrd r8, r9, 0x9;\n"
        "shrd r9, r10, 0x9;\n"
        "shrd r10, r11, 0x9;\n"
        "shrd r11, r12, 0x9;\n"
        "shrd r12, r13, 0x9;\n"
        "shrd r13, r14, 0x9;\n"
        "shrd r14, r15, 0x9;\n"
        "shrd r15, rcx, 0x9;\n"
        "shr rcx, 0x9;\n"
        "add rcx, rax;\n"
        "stc;\n"
        "adc r8, [rsp + 504];\n"
        "adc r9, [rsp + 512];\n"
        "adc r10, [rsp + 520];\n"
        "adc r11, [rsp + 528];\n"
        "adc r12, [rsp + 536];\n"
        "adc r13, [rsp + 544];\n"
        "adc r14, [rsp + 552];\n"
        "adc r15, [rsp + 560];\n"
        "adc rcx, 0xfffffffffffffe00;\n"
        "cmc;\n"
        "sbb r8, 0x0;\n"
        "mov [" $P0 "], r8;\n"
        "sbb r9, 0x0;\n"
        "mov [" $P0 "+ 0x8], r9;\n"
        "sbb r10, 0x0;\n"
        "mov [" $P0 "+ 0x10], r10;\n"
        "sbb r11, 0x0;\n"
        "mov [" $P0 "+ 0x18], r11;\n"
        "sbb r12, 0x0;\n"
        "mov [" $P0 "+ 0x20], r12;\n"
        "sbb r13, 0x0;\n"
        "mov [" $P0 "+ 0x28], r13;\n"
        "sbb r14, 0x0;\n"
        "mov [" $P0 "+ 0x30], r14;\n"
        "sbb r15, 0x0;\n"
        "mov [" $P0 "+ 0x38], r15;\n"
        "sbb rcx, 0x0;\n"
        "and rcx, 0x1ff;\n"
        "mov [" $P0 "+ 0x40], rcx"
    )}
}

// Corresponds exactly to bignum_add_p521

macro_rules! add_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "stc;\n"
        "mov rax, [" $P1 "];\n"
        "adc rax, [" $P2 "];\n"
        "mov rbx, [" $P1 "+ 0x8];\n"
        "adc rbx, [" $P2 "+ 0x8];\n"
        "mov r8, [" $P1 "+ 0x10];\n"
        "adc r8, [" $P2 "+ 0x10];\n"
        "mov r9, [" $P1 "+ 0x18];\n"
        "adc r9, [" $P2 "+ 0x18];\n"
        "mov r10, [" $P1 "+ 0x20];\n"
        "adc r10, [" $P2 "+ 0x20];\n"
        "mov r11, [" $P1 "+ 0x28];\n"
        "adc r11, [" $P2 "+ 0x28];\n"
        "mov r12, [" $P1 "+ 0x30];\n"
        "adc r12, [" $P2 "+ 0x30];\n"
        "mov r13, [" $P1 "+ 0x38];\n"
        "adc r13, [" $P2 "+ 0x38];\n"
        "mov r14, [" $P1 "+ 0x40];\n"
        "adc r14, [" $P2 "+ 0x40];\n"
        "mov rdx, 0x200;\n"
        "and rdx, r14;\n"
        "cmp rdx, 0x200;\n"
        "sbb rax, 0x0;\n"
        "mov [" $P0 "], rax;\n"
        "sbb rbx, 0x0;\n"
        "mov [" $P0 "+ 0x8], rbx;\n"
        "sbb r8, 0x0;\n"
        "mov [" $P0 "+ 0x10], r8;\n"
        "sbb r9, 0x0;\n"
        "mov [" $P0 "+ 0x18], r9;\n"
        "sbb r10, 0x0;\n"
        "mov [" $P0 "+ 0x20], r10;\n"
        "sbb r11, 0x0;\n"
        "mov [" $P0 "+ 0x28], r11;\n"
        "sbb r12, 0x0;\n"
        "mov [" $P0 "+ 0x30], r12;\n"
        "sbb r13, 0x0;\n"
        "mov [" $P0 "+ 0x38], r13;\n"
        "sbb r14, rdx;\n"
        "mov [" $P0 "+ 0x40], r14"
    )}
}

// Corresponds exactly to bignum_sub_p521

macro_rules! sub_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "mov rax, [" $P1 "];\n"
        "sub rax, [" $P2 "];\n"
        "mov rdx, [" $P1 "+ 0x8];\n"
        "sbb rdx, [" $P2 "+ 0x8];\n"
        "mov r8, [" $P1 "+ 0x10];\n"
        "sbb r8, [" $P2 "+ 0x10];\n"
        "mov r9, [" $P1 "+ 0x18];\n"
        "sbb r9, [" $P2 "+ 0x18];\n"
        "mov r10, [" $P1 "+ 0x20];\n"
        "sbb r10, [" $P2 "+ 0x20];\n"
        "mov r11, [" $P1 "+ 0x28];\n"
        "sbb r11, [" $P2 "+ 0x28];\n"
        "mov r12, [" $P1 "+ 0x30];\n"
        "sbb r12, [" $P2 "+ 0x30];\n"
        "mov r13, [" $P1 "+ 0x38];\n"
        "sbb r13, [" $P2 "+ 0x38];\n"
        "mov r14, [" $P1 "+ 0x40];\n"
        "sbb r14, [" $P2 "+ 0x40];\n"
        "sbb rax, 0x0;\n"
        "mov [" $P0 "], rax;\n"
        "sbb rdx, 0x0;\n"
        "mov [" $P0 "+ 0x8], rdx;\n"
        "sbb r8, 0x0;\n"
        "mov [" $P0 "+ 0x10], r8;\n"
        "sbb r9, 0x0;\n"
        "mov [" $P0 "+ 0x18], r9;\n"
        "sbb r10, 0x0;\n"
        "mov [" $P0 "+ 0x20], r10;\n"
        "sbb r11, 0x0;\n"
        "mov [" $P0 "+ 0x28], r11;\n"
        "sbb r12, 0x0;\n"
        "mov [" $P0 "+ 0x30], r12;\n"
        "sbb r13, 0x0;\n"
        "mov [" $P0 "+ 0x38], r13;\n"
        "sbb r14, 0x0;\n"
        "and r14, 0x1ff;\n"
        "mov [" $P0 "+ 0x40], r14"
    )}
}

// Weak multiplication not fully reducing

macro_rules! weakmul_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "xor ecx, ecx;\n"
        "mov rdx, [" $P2 "];\n"
        "mulx r9, r8, [" $P1 "];\n"
        "mov [rsp + 504], r8;\n"
        "mulx r10, rbx, [" $P1 "+ 0x8];\n"
        "adc r9, rbx;\n"
        "mulx r11, rbx, [" $P1 "+ 0x10];\n"
        "adc r10, rbx;\n"
        "mulx r12, rbx, [" $P1 "+ 0x18];\n"
        "adc r11, rbx;\n"
        "mulx r13, rbx, [" $P1 "+ 0x20];\n"
        "adc r12, rbx;\n"
        "mulx r14, rbx, [" $P1 "+ 0x28];\n"
        "adc r13, rbx;\n"
        "mulx r15, rbx, [" $P1 "+ 0x30];\n"
        "adc r14, rbx;\n"
        "mulx r8, rbx, [" $P1 "+ 0x38];\n"
        "adc r15, rbx;\n"
        "adc r8, rcx;\n"
        "mov rdx, [" $P2 "+ 0x8];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mov [rsp + 512], r9;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx r9, rax, [" $P1 "+ 0x38];\n"
        "adcx r8, rax;\n"
        "adox r9, rcx;\n"
        "adc r9, rcx;\n"
        "mov rdx, [" $P2 "+ 0x10];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mov [rsp + 520], r10;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx r10, rax, [" $P1 "+ 0x38];\n"
        "adcx r9, rax;\n"
        "adox r10, rcx;\n"
        "adc r10, rcx;\n"
        "mov rdx, [" $P2 "+ 0x18];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mov [rsp + 528], r11;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx r11, rax, [" $P1 "+ 0x38];\n"
        "adcx r10, rax;\n"
        "adox r11, rcx;\n"
        "adc r11, rcx;\n"
        "mov rdx, [" $P2 "+ 0x20];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mov [rsp + 536], r12;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx r12, rax, [" $P1 "+ 0x38];\n"
        "adcx r11, rax;\n"
        "adox r12, rcx;\n"
        "adc r12, rcx;\n"
        "mov rdx, [" $P2 "+ 0x28];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mov [rsp + 544], r13;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx r13, rax, [" $P1 "+ 0x38];\n"
        "adcx r12, rax;\n"
        "adox r13, rcx;\n"
        "adc r13, rcx;\n"
        "mov rdx, [" $P2 "+ 0x30];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mov [rsp + 552], r14;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx r14, rax, [" $P1 "+ 0x38];\n"
        "adcx r13, rax;\n"
        "adox r14, rcx;\n"
        "adc r14, rcx;\n"
        "mov rdx, [" $P2 "+ 0x38];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r15, rax;\n"
        "adox r8, rbx;\n"
        "mov [rsp + 560], r15;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx r15, rax, [" $P1 "+ 0x38];\n"
        "adcx r14, rax;\n"
        "adox r15, rcx;\n"
        "adc r15, rcx;\n"
        "mov rdx, [" $P1 "+ 0x40];\n"
        "xor ecx, ecx;\n"
        "mulx rbx, rax, [" $P2 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x8];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x18];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x28];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P2 "+ 0x38];\n"
        "adcx r15, rax;\n"
        "adox rbx, rcx;\n"
        "adc rcx, rbx;\n"
        "mov rdx, [" $P2 "+ 0x40];\n"
        "xor eax, eax;\n"
        "mulx rbx, rax, [" $P1 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x8];\n"
        "adcx r9, rax;\n"
        "adox r10, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x10];\n"
        "adcx r10, rax;\n"
        "adox r11, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x18];\n"
        "adcx r11, rax;\n"
        "adox r12, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x20];\n"
        "adcx r12, rax;\n"
        "adox r13, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x28];\n"
        "adcx r13, rax;\n"
        "adox r14, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x30];\n"
        "adcx r14, rax;\n"
        "adox r15, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x38];\n"
        "adcx r15, rax;\n"
        "adox rcx, rbx;\n"
        "mulx rbx, rax, [" $P1 "+ 0x40];\n"
        "adc rcx, rax;\n"
        "mov rax, r8;\n"
        "and rax, 0x1ff;\n"
        "shrd r8, r9, 0x9;\n"
        "shrd r9, r10, 0x9;\n"
        "shrd r10, r11, 0x9;\n"
        "shrd r11, r12, 0x9;\n"
        "shrd r12, r13, 0x9;\n"
        "shrd r13, r14, 0x9;\n"
        "shrd r14, r15, 0x9;\n"
        "shrd r15, rcx, 0x9;\n"
        "shr rcx, 0x9;\n"
        "add rcx, rax;\n"
        "add r8, [rsp + 504];\n"
        "mov [" $P0 "], r8;\n"
        "adc r9, [rsp + 512];\n"
        "mov [" $P0 "+ 0x8], r9;\n"
        "adc r10, [rsp + 520];\n"
        "mov [" $P0 "+ 0x10], r10;\n"
        "adc r11, [rsp + 528];\n"
        "mov [" $P0 "+ 0x18], r11;\n"
        "adc r12, [rsp + 536];\n"
        "mov [" $P0 "+ 0x20], r12;\n"
        "adc r13, [rsp + 544];\n"
        "mov [" $P0 "+ 0x28], r13;\n"
        "adc r14, [rsp + 552];\n"
        "mov [" $P0 "+ 0x30], r14;\n"
        "adc r15, [rsp + 560];\n"
        "mov [" $P0 "+ 0x38], r15;\n"
        "adc rcx, 0;\n"
        "mov [" $P0 "+ 0x40], rcx"
    )}
}

// P0 = C * P1 - D * P2 == C * P1 + D * (p_521 - P2)

macro_rules! cmsub_p521 {
    ($P0:expr, $C:expr, $P1:expr, $D:expr, $P2:expr) => { Q!(
        "mov rdx, " $D ";\n"
        "mov rbx, [" $P2 "+ 64];\n"
        "xor rbx, 0x1FF;\n"
        "mov rax, [" $P2 "];\n"
        "not rax;\n"
        "mulx r9, r8, rax;\n"
        "mov rax, [" $P2 "+ 8];\n"
        "not rax;\n"
        "mulx r10, rax, rax;\n"
        "add r9, rax;\n"
        "mov rax, [" $P2 "+ 16];\n"
        "not rax;\n"
        "mulx r11, rax, rax;\n"
        "adc r10, rax;\n"
        "mov rax, [" $P2 "+ 24];\n"
        "not rax;\n"
        "mulx r12, rax, rax;\n"
        "adc r11, rax;\n"
        "mov rax, [" $P2 "+ 32];\n"
        "not rax;\n"
        "mulx r13, rax, rax;\n"
        "adc r12, rax;\n"
        "mov rax, [" $P2 "+ 40];\n"
        "not rax;\n"
        "mulx r14, rax, rax;\n"
        "adc r13, rax;\n"
        "mov rax, [" $P2 "+ 48];\n"
        "not rax;\n"
        "mulx r15, rax, rax;\n"
        "adc r14, rax;\n"
        "mov rax, [" $P2 "+ 56];\n"
        "not rax;\n"
        "mulx rcx, rax, rax;\n"
        "adc r15, rax;\n"
        "mulx rax, rbx, rbx;\n"
        "adc rbx, rcx;\n"
        "xor eax, eax;\n"
        "mov rdx, " $C ";\n"
        "mulx rcx, rax, [" $P1 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 8];\n"
        "adcx r9, rax;\n"
        "adox r10, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 16];\n"
        "adcx r10, rax;\n"
        "adox r11, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 24];\n"
        "adcx r11, rax;\n"
        "adox r12, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 32];\n"
        "adcx r12, rax;\n"
        "adox r13, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 40];\n"
        "adcx r13, rax;\n"
        "adox r14, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 48];\n"
        "adcx r14, rax;\n"
        "adox r15, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 56];\n"
        "adcx r15, rax;\n"
        "adox rbx, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 64];\n"
        "adcx rbx, rax;\n"
        "mov rax, r9;\n"
        "and rax, r10;\n"
        "and rax, r11;\n"
        "and rax, r12;\n"
        "and rax, r13;\n"
        "and rax, r14;\n"
        "and rax, r15;\n"
        "mov rdx, rbx;\n"
        "shr rdx, 9;\n"
        "or rbx, ~ 0x1FF;\n"
        "lea rcx, [rdx + 1];\n"
        "add rcx, r8;\n"
        "mov ecx, 0;\n"
        "adc rax, rcx;\n"
        "mov rax, rbx;\n"
        "adc rax, rcx;\n"
        "adc r8, rdx;\n"
        "mov [" $P0 "], r8;\n"
        "adc r9, rcx;\n"
        "mov [" $P0 "+ 8], r9;\n"
        "adc r10, rcx;\n"
        "mov [" $P0 "+ 16], r10;\n"
        "adc r11, rcx;\n"
        "mov [" $P0 "+ 24], r11;\n"
        "adc r12, rcx;\n"
        "mov [" $P0 "+ 32], r12;\n"
        "adc r13, rcx;\n"
        "mov [" $P0 "+ 40], r13;\n"
        "adc r14, rcx;\n"
        "mov [" $P0 "+ 48], r14;\n"
        "adc r15, rcx;\n"
        "mov [" $P0 "+ 56], r15;\n"
        "adc rbx, rcx;\n"
        "and rbx, 0x1FF;\n"
        "mov [" $P0 "+ 64], rbx"
    )}
}

// P0 = 3 * P1 - 8 * P2 == 3 * P1 + 8 * (p_521 - P2)

macro_rules! cmsub38_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "mov rbx, [" $P2 "+ 64];\n"
        "xor rbx, 0x1FF;\n"
        "mov r15, [" $P2 "+ 56];\n"
        "not r15;\n"
        "shld rbx, r15, 3;\n"
        "mov r14, [" $P2 "+ 48];\n"
        "not r14;\n"
        "shld r15, r14, 3;\n"
        "mov r13, [" $P2 "+ 40];\n"
        "not r13;\n"
        "shld r14, r13, 3;\n"
        "mov r12, [" $P2 "+ 32];\n"
        "not r12;\n"
        "shld r13, r12, 3;\n"
        "mov r11, [" $P2 "+ 24];\n"
        "not r11;\n"
        "shld r12, r11, 3;\n"
        "mov r10, [" $P2 "+ 16];\n"
        "not r10;\n"
        "shld r11, r10, 3;\n"
        "mov r9, [" $P2 "+ 8];\n"
        "not r9;\n"
        "shld r10, r9, 3;\n"
        "mov r8, [" $P2 "];\n"
        "not r8;\n"
        "shld r9, r8, 3;\n"
        "shl r8, 3;\n"
        "mov rdx, 3;\n"
        "xor eax, eax;\n"
        "mulx rcx, rax, [" $P1 "];\n"
        "adcx r8, rax;\n"
        "adox r9, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 8];\n"
        "adcx r9, rax;\n"
        "adox r10, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 16];\n"
        "adcx r10, rax;\n"
        "adox r11, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 24];\n"
        "adcx r11, rax;\n"
        "adox r12, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 32];\n"
        "adcx r12, rax;\n"
        "adox r13, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 40];\n"
        "adcx r13, rax;\n"
        "adox r14, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 48];\n"
        "adcx r14, rax;\n"
        "adox r15, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 56];\n"
        "adcx r15, rax;\n"
        "adox rbx, rcx;\n"
        "mulx rcx, rax, [" $P1 "+ 64];\n"
        "adcx rbx, rax;\n"
        "mov rax, r9;\n"
        "and rax, r10;\n"
        "and rax, r11;\n"
        "and rax, r12;\n"
        "and rax, r13;\n"
        "and rax, r14;\n"
        "and rax, r15;\n"
        "mov rdx, rbx;\n"
        "shr rdx, 9;\n"
        "or rbx, ~ 0x1FF;\n"
        "lea rcx, [rdx + 1];\n"
        "add rcx, r8;\n"
        "mov ecx, 0;\n"
        "adc rax, rcx;\n"
        "mov rax, rbx;\n"
        "adc rax, rcx;\n"
        "adc r8, rdx;\n"
        "mov [" $P0 "], r8;\n"
        "adc r9, rcx;\n"
        "mov [" $P0 "+ 8], r9;\n"
        "adc r10, rcx;\n"
        "mov [" $P0 "+ 16], r10;\n"
        "adc r11, rcx;\n"
        "mov [" $P0 "+ 24], r11;\n"
        "adc r12, rcx;\n"
        "mov [" $P0 "+ 32], r12;\n"
        "adc r13, rcx;\n"
        "mov [" $P0 "+ 40], r13;\n"
        "adc r14, rcx;\n"
        "mov [" $P0 "+ 48], r14;\n"
        "adc r15, rcx;\n"
        "mov [" $P0 "+ 56], r15;\n"
        "adc rbx, rcx;\n"
        "and rbx, 0x1FF;\n"
        "mov [" $P0 "+ 64], rbx"
    )}
}

// P0 = 4 * P1 - P2 = 4 * P1 + (p_521 - P2)

macro_rules! cmsub41_p521 {
    ($P0:expr, $P1:expr, $P2:expr) => { Q!(
        "mov rbx, [" $P1 "+ 64];\n"
        "mov r15, [" $P1 "+ 56];\n"
        "shld rbx, r15, 2;\n"
        "mov r14, [" $P1 "+ 48];\n"
        "shld r15, r14, 2;\n"
        "mov r13, [" $P1 "+ 40];\n"
        "shld r14, r13, 2;\n"
        "mov r12, [" $P1 "+ 32];\n"
        "shld r13, r12, 2;\n"
        "mov r11, [" $P1 "+ 24];\n"
        "shld r12, r11, 2;\n"
        "mov r10, [" $P1 "+ 16];\n"
        "shld r11, r10, 2;\n"
        "mov r9, [" $P1 "+ 8];\n"
        "shld r10, r9, 2;\n"
        "mov r8, [" $P1 "];\n"
        "shld r9, r8, 2;\n"
        "shl r8, 2;\n"
        "mov rcx, [" $P2 "+ 64];\n"
        "xor rcx, 0x1FF;\n"
        "mov rax, [" $P2 "];\n"
        "not rax;\n"
        "add r8, rax;\n"
        "mov rax, [" $P2 "+ 8];\n"
        "not rax;\n"
        "adc r9, rax;\n"
        "mov rax, [" $P2 "+ 16];\n"
        "not rax;\n"
        "adc r10, rax;\n"
        "mov rax, [" $P2 "+ 24];\n"
        "not rax;\n"
        "adc r11, rax;\n"
        "mov rax, [" $P2 "+ 32];\n"
        "not rax;\n"
        "adc r12, rax;\n"
        "mov rax, [" $P2 "+ 40];\n"
        "not rax;\n"
        "adc r13, rax;\n"
        "mov rax, [" $P2 "+ 48];\n"
        "not rax;\n"
        "adc r14, rax;\n"
        "mov rax, [" $P2 "+ 56];\n"
        "not rax;\n"
        "adc r15, rax;\n"
        "adc rbx, rcx;\n"
        "mov rax, r9;\n"
        "and rax, r10;\n"
        "and rax, r11;\n"
        "and rax, r12;\n"
        "and rax, r13;\n"
        "and rax, r14;\n"
        "and rax, r15;\n"
        "mov rdx, rbx;\n"
        "shr rdx, 9;\n"
        "or rbx, ~ 0x1FF;\n"
        "lea rcx, [rdx + 1];\n"
        "add rcx, r8;\n"
        "mov ecx, 0;\n"
        "adc rax, rcx;\n"
        "mov rax, rbx;\n"
        "adc rax, rcx;\n"
        "adc r8, rdx;\n"
        "mov [" $P0 "], r8;\n"
        "adc r9, rcx;\n"
        "mov [" $P0 "+ 8], r9;\n"
        "adc r10, rcx;\n"
        "mov [" $P0 "+ 16], r10;\n"
        "adc r11, rcx;\n"
        "mov [" $P0 "+ 24], r11;\n"
        "adc r12, rcx;\n"
        "mov [" $P0 "+ 32], r12;\n"
        "adc r13, rcx;\n"
        "mov [" $P0 "+ 40], r13;\n"
        "adc r14, rcx;\n"
        "mov [" $P0 "+ 48], r14;\n"
        "adc r15, rcx;\n"
        "mov [" $P0 "+ 56], r15;\n"
        "adc rbx, rcx;\n"
        "and rbx, 0x1FF;\n"
        "mov [" $P0 "+ 64], rbx"
    )}
}

/// Point doubling on NIST curve P-521 in Jacobian coordinates
///
///
/// Does p3 := 2 * p1 where all points are regarded as Jacobian triples.
/// A Jacobian triple (x,y,z) represents affine point (x/z^2,y/z^3).
/// It is assumed that all coordinates of the input point are fully
/// reduced mod p_521 and that the z coordinate is not zero.
pub(crate) fn p521_jdouble(p3: &mut [u64; 27], p1: &[u64; 27]) {
    // SAFETY: inline assembly. see [crate::low::inline_assembly_safety] for safety info.
    unsafe {
        core::arch::asm!(

        Q!("    endbr64         " ),

        // Save registers and make room on stack for temporary variables

        Q!("    push            " "rbx"),
        Q!("    push            " "r12"),
        Q!("    push            " "r13"),
        Q!("    push            " "r14"),
        Q!("    push            " "r15"),

        Q!("    sub             " "rsp, " NSPACE!()),

        // Main code, just a sequence of basic field operations

        // z2 = z^2
        // y2 = y^2

        sqr_p521!(z2!(), z_1!()),
        sqr_p521!(y2!(), y_1!()),

        // x2p = x^2 - z^4 = (x + z^2) * (x - z^2)

        add_p521!(t1!(), x_1!(), z2!()),
        sub_p521!(t2!(), x_1!(), z2!()),
        mul_p521!(x2p!(), t1!(), t2!()),

        // t1 = y + z
        // x4p = x2p^2
        // xy2 = x * y^2

        add_p521!(t1!(), y_1!(), z_1!()),
        sqr_p521!(x4p!(), x2p!()),
        weakmul_p521!(xy2!(), x_1!(), y2!()),

        // t2 = (y + z)^2

        sqr_p521!(t2!(), t1!()),

        // d = 12 * xy2 - 9 * x4p
        // t1 = y^2 + 2 * y * z

        cmsub_p521!(d!(), "12", xy2!(), "9", x4p!()),
        sub_p521!(t1!(), t2!(), z2!()),

        // y4 = y^4

        sqr_p521!(y4!(), y2!()),

        // z_3' = 2 * y * z
        // dx2 = d * x2p

        sub_p521!(z_3!(), t1!(), y2!()),
        weakmul_p521!(dx2!(), d!(), x2p!()),

        // x' = 4 * xy2 - d

        cmsub41_p521!(x_3!(), xy2!(), d!()),

        // y' = 3 * dx2 - 8 * y4

        cmsub38_p521!(y_3!(), dx2!(), y4!()),

        // Restore stack and registers

        Q!("    add             " "rsp, " NSPACE!()),
        Q!("    pop             " "r15"),
        Q!("    pop             " "r14"),
        Q!("    pop             " "r13"),
        Q!("    pop             " "r12"),
        Q!("    pop             " "rbx"),

        inout("rdi") p3.as_mut_ptr() => _,
        inout("rsi") p1.as_ptr() => _,
        // clobbers
        out("r10") _,
        out("r11") _,
        out("r12") _,
        out("r13") _,
        out("r14") _,
        out("r15") _,
        out("r8") _,
        out("r9") _,
        out("rax") _,
        out("rcx") _,
        out("rdx") _,
            )
    };
}