|
| 1 | +// Copyright (c) 2014 Pieter Wuille |
| 2 | +// Distributed under the MIT software license, see the accompanying |
| 3 | +// file COPYING or http://www.opensource.org/licenses/mit-license.php. |
| 4 | + |
| 5 | +#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_ |
| 6 | +#define _SECP256K1_SCALAR_REPR_IMPL_H_ |
| 7 | + |
| 8 | +typedef unsigned __int128 uint128_t; |
| 9 | + |
| 10 | +// Limbs of the secp256k1 order. |
| 11 | +#define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL) |
| 12 | +#define SECP256K1_N_1 ((uint64_t)0xBAAEDCE6AF48A03BULL) |
| 13 | +#define SECP256K1_N_2 ((uint64_t)0xFFFFFFFFFFFFFFFEULL) |
| 14 | +#define SECP256K1_N_3 ((uint64_t)0xFFFFFFFFFFFFFFFFULL) |
| 15 | + |
| 16 | +// Limbs of 2^256 minus the secp256k1 order. |
| 17 | +#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1) |
| 18 | +#define SECP256K1_N_C_1 (~SECP256K1_N_1) |
| 19 | +#define SECP256K1_N_C_2 (1) |
| 20 | + |
| 21 | +// Limbs of half the secp256k1 order. |
| 22 | +#define SECP256K1_N_H_0 ((uint64_t)0xDFE92F46681B20A0ULL) |
| 23 | +#define SECP256K1_N_H_1 ((uint64_t)0x5D576E7357A4501DULL) |
| 24 | +#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL) |
| 25 | +#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL) |
| 26 | + |
| 27 | +void static inline secp256k1_scalar_clear(secp256k1_scalar_t *r) { |
| 28 | + r->d[0] = 0; |
| 29 | + r->d[1] = 0; |
| 30 | + r->d[2] = 0; |
| 31 | + r->d[3] = 0; |
| 32 | +} |
| 33 | + |
| 34 | +int static inline secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, int offset, int count) { |
| 35 | + VERIFY_CHECK((offset + count - 1) / 64 == offset / 64); |
| 36 | + return (a->d[offset / 64] >> (offset % 64)) & ((((uint64_t)1) << count) - 1); |
| 37 | +} |
| 38 | + |
| 39 | +int static inline secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) { |
| 40 | + int yes = 0; |
| 41 | + int no = 0; |
| 42 | + no |= (a->d[3] < SECP256K1_N_3); // No need for a > check. |
| 43 | + no |= (a->d[2] < SECP256K1_N_2); |
| 44 | + yes |= (a->d[2] > SECP256K1_N_2) & ~no; |
| 45 | + no |= (a->d[1] < SECP256K1_N_1); |
| 46 | + yes |= (a->d[1] > SECP256K1_N_1) & ~no; |
| 47 | + yes |= (a->d[0] >= SECP256K1_N_0) & ~no; |
| 48 | + return yes; |
| 49 | +} |
| 50 | + |
| 51 | +int static inline secp256k1_scalar_reduce(secp256k1_scalar_t *r, unsigned int overflow) { |
| 52 | + VERIFY_CHECK(overflow <= 1); |
| 53 | + uint128_t t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0; |
| 54 | + r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 55 | + t += (uint128_t)r->d[1] + overflow * SECP256K1_N_C_1; |
| 56 | + r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 57 | + t += (uint128_t)r->d[2] + overflow * SECP256K1_N_C_2; |
| 58 | + r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 59 | + t += (uint64_t)r->d[3]; |
| 60 | + r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL; |
| 61 | + return overflow; |
| 62 | +} |
| 63 | + |
| 64 | +void static secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) { |
| 65 | + uint128_t t = (uint128_t)a->d[0] + b->d[0]; |
| 66 | + r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 67 | + t += (uint128_t)a->d[1] + b->d[1]; |
| 68 | + r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 69 | + t += (uint128_t)a->d[2] + b->d[2]; |
| 70 | + r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 71 | + t += (uint128_t)a->d[3] + b->d[3]; |
| 72 | + r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64; |
| 73 | + secp256k1_scalar_reduce(r, t + secp256k1_scalar_check_overflow(r)); |
| 74 | +} |
| 75 | + |
| 76 | +void static secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) { |
| 77 | + r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56; |
| 78 | + r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56; |
| 79 | + r->d[2] = (uint64_t)b32[15] | (uint64_t)b32[14] << 8 | (uint64_t)b32[13] << 16 | (uint64_t)b32[12] << 24 | (uint64_t)b32[11] << 32 | (uint64_t)b32[10] << 40 | (uint64_t)b32[9] << 48 | (uint64_t)b32[8] << 56; |
| 80 | + r->d[3] = (uint64_t)b32[7] | (uint64_t)b32[6] << 8 | (uint64_t)b32[5] << 16 | (uint64_t)b32[4] << 24 | (uint64_t)b32[3] << 32 | (uint64_t)b32[2] << 40 | (uint64_t)b32[1] << 48 | (uint64_t)b32[0] << 56; |
| 81 | + int over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r)); |
| 82 | + if (overflow) { |
| 83 | + *overflow = over; |
| 84 | + } |
| 85 | +} |
| 86 | + |
| 87 | +void static secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) { |
| 88 | + bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3]; |
| 89 | + bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2]; |
| 90 | + bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1]; |
| 91 | + bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0]; |
| 92 | +} |
| 93 | + |
| 94 | +int static inline secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) { |
| 95 | + return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0; |
| 96 | +} |
| 97 | + |
| 98 | +void static secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) { |
| 99 | + uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0); |
| 100 | + uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1; |
| 101 | + r->d[0] = t & nonzero; t >>= 64; |
| 102 | + t += (uint128_t)(~a->d[1]) + SECP256K1_N_1; |
| 103 | + r->d[1] = t & nonzero; t >>= 64; |
| 104 | + t += (uint128_t)(~a->d[2]) + SECP256K1_N_2; |
| 105 | + r->d[2] = t & nonzero; t >>= 64; |
| 106 | + t += (uint128_t)(~a->d[3]) + SECP256K1_N_3; |
| 107 | + r->d[3] = t & nonzero; |
| 108 | +} |
| 109 | + |
| 110 | +int static inline secp256k1_scalar_is_one(const secp256k1_scalar_t *a) { |
| 111 | + return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0; |
| 112 | +} |
| 113 | + |
| 114 | +int static secp256k1_scalar_is_high(const secp256k1_scalar_t *a) { |
| 115 | + int yes = 0; |
| 116 | + int no = 0; |
| 117 | + no |= (a->d[3] < SECP256K1_N_H_3); |
| 118 | + yes |= (a->d[3] > SECP256K1_N_H_3) & ~no; |
| 119 | + no |= (a->d[2] < SECP256K1_N_H_2) & ~yes; // No need for a > check. |
| 120 | + no |= (a->d[1] < SECP256K1_N_H_1) & ~yes; |
| 121 | + yes |= (a->d[1] > SECP256K1_N_H_1) & ~no; |
| 122 | + yes |= (a->d[0] > SECP256K1_N_H_0) & ~no; |
| 123 | + return yes; |
| 124 | +} |
| 125 | + |
| 126 | +// Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. |
| 127 | + |
| 128 | +/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */ |
| 129 | +#define muladd(a,b) { \ |
| 130 | + uint64_t tl, th; \ |
| 131 | + { \ |
| 132 | + uint128_t t = (uint128_t)a * b; \ |
| 133 | + th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \ |
| 134 | + tl = t; \ |
| 135 | + } \ |
| 136 | + c0 += tl; /* overflow is handled on the next line */ \ |
| 137 | + th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \ |
| 138 | + c1 += th; /* overflow is handled on the next line */ \ |
| 139 | + c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \ |
| 140 | + VERIFY_CHECK((c1 >= th) || (c2 != 0)); \ |
| 141 | +} |
| 142 | + |
| 143 | +/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */ |
| 144 | +#define muladd_fast(a,b) { \ |
| 145 | + uint64_t tl, th; \ |
| 146 | + { \ |
| 147 | + uint128_t t = (uint128_t)a * b; \ |
| 148 | + th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \ |
| 149 | + tl = t; \ |
| 150 | + } \ |
| 151 | + c0 += tl; /* overflow is handled on the next line */ \ |
| 152 | + th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \ |
| 153 | + c1 += th; /* never overflows by contract (verified in the next line) */ \ |
| 154 | + VERIFY_CHECK(c1 >= th); \ |
| 155 | +} |
| 156 | + |
| 157 | +/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */ |
| 158 | +#define muladd2(a,b) { \ |
| 159 | + uint64_t tl, th; \ |
| 160 | + { \ |
| 161 | + uint128_t t = (uint128_t)a * b; \ |
| 162 | + th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \ |
| 163 | + tl = t; \ |
| 164 | + } \ |
| 165 | + uint64_t th2 = th + th; /* at most 0xFFFFFFFFFFFFFFFE (in case th was 0x7FFFFFFFFFFFFFFF) */ \ |
| 166 | + c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \ |
| 167 | + VERIFY_CHECK((th2 >= th) || (c2 != 0)); \ |
| 168 | + uint64_t tl2 = tl + tl; /* at most 0xFFFFFFFFFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFFFFFFFFFF) */ \ |
| 169 | + th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \ |
| 170 | + c0 += tl2; /* overflow is handled on the next line */ \ |
| 171 | + th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \ |
| 172 | + c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \ |
| 173 | + VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \ |
| 174 | + c1 += th2; /* overflow is handled on the next line */ \ |
| 175 | + c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \ |
| 176 | + VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \ |
| 177 | +} |
| 178 | + |
| 179 | +/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */ |
| 180 | +#define sumadd(a) { \ |
| 181 | + c0 += (a); /* overflow is handled on the next line */ \ |
| 182 | + int over = (c0 < (a)) ? 1 : 0; \ |
| 183 | + c1 += over; /* overflow is handled on the next line */ \ |
| 184 | + c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \ |
| 185 | +} |
| 186 | + |
| 187 | +/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */ |
| 188 | +#define sumadd_fast(a) { \ |
| 189 | + c0 += (a); /* overflow is handled on the next line */ \ |
| 190 | + c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \ |
| 191 | + VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \ |
| 192 | + VERIFY_CHECK(c2 == 0); \ |
| 193 | +} |
| 194 | + |
| 195 | +/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. */ |
| 196 | +#define extract(n) { \ |
| 197 | + (n) = c0; \ |
| 198 | + c0 = c1; \ |
| 199 | + c1 = c2; \ |
| 200 | + c2 = 0; \ |
| 201 | +} |
| 202 | + |
| 203 | +/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. c2 is required to be zero. */ |
| 204 | +#define extract_fast(n) { \ |
| 205 | + (n) = c0; \ |
| 206 | + c0 = c1; \ |
| 207 | + c1 = 0; \ |
| 208 | + VERIFY_CHECK(c2 == 0); \ |
| 209 | +} |
| 210 | + |
| 211 | +void static secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint64_t *l) { |
| 212 | + uint64_t n0 = l[4], n1 = l[5], n2 = l[6], n3 = l[7]; |
| 213 | + |
| 214 | + // 160 bit accumulator. |
| 215 | + uint64_t c0, c1; |
| 216 | + uint32_t c2; |
| 217 | + |
| 218 | + // Reduce 512 bits into 385. |
| 219 | + // m[0..6] = l[0..3] + n[0..3] * SECP256K1_N_C. |
| 220 | + c0 = l[0]; c1 = 0; c2 = 0; |
| 221 | + muladd_fast(n0, SECP256K1_N_C_0); |
| 222 | + uint64_t m0; extract_fast(m0); |
| 223 | + sumadd_fast(l[1]); |
| 224 | + muladd(n1, SECP256K1_N_C_0); |
| 225 | + muladd(n0, SECP256K1_N_C_1); |
| 226 | + uint64_t m1; extract(m1); |
| 227 | + sumadd(l[2]); |
| 228 | + muladd(n2, SECP256K1_N_C_0); |
| 229 | + muladd(n1, SECP256K1_N_C_1); |
| 230 | + sumadd(n0); |
| 231 | + uint64_t m2; extract(m2); |
| 232 | + sumadd(l[3]); |
| 233 | + muladd(n3, SECP256K1_N_C_0); |
| 234 | + muladd(n2, SECP256K1_N_C_1); |
| 235 | + sumadd(n1); |
| 236 | + uint64_t m3; extract(m3); |
| 237 | + muladd(n3, SECP256K1_N_C_1); |
| 238 | + sumadd(n2); |
| 239 | + uint64_t m4; extract(m4); |
| 240 | + sumadd_fast(n3); |
| 241 | + uint64_t m5; extract_fast(m5); |
| 242 | + VERIFY_CHECK(c0 <= 1); |
| 243 | + uint32_t m6 = c0; |
| 244 | + |
| 245 | + // Reduce 385 bits into 258. |
| 246 | + // p[0..4] = m[0..3] + m[4..6] * SECP256K1_N_C. |
| 247 | + c0 = m0; c1 = 0; c2 = 0; |
| 248 | + muladd_fast(m4, SECP256K1_N_C_0); |
| 249 | + uint64_t p0; extract_fast(p0); |
| 250 | + sumadd_fast(m1); |
| 251 | + muladd(m5, SECP256K1_N_C_0); |
| 252 | + muladd(m4, SECP256K1_N_C_1); |
| 253 | + uint64_t p1; extract(p1); |
| 254 | + sumadd(m2); |
| 255 | + muladd(m6, SECP256K1_N_C_0); |
| 256 | + muladd(m5, SECP256K1_N_C_1); |
| 257 | + sumadd(m4); |
| 258 | + uint64_t p2; extract(p2); |
| 259 | + sumadd_fast(m3); |
| 260 | + muladd_fast(m6, SECP256K1_N_C_1); |
| 261 | + sumadd_fast(m5); |
| 262 | + uint64_t p3; extract_fast(p3); |
| 263 | + uint32_t p4 = c0 + m6; |
| 264 | + VERIFY_CHECK(p4 <= 2); |
| 265 | + |
| 266 | + // Reduce 258 bits into 256. |
| 267 | + // r[0..3] = p[0..3] + p[4] * SECP256K1_N_C. |
| 268 | + uint128_t c = p0 + (uint128_t)SECP256K1_N_C_0 * p4; |
| 269 | + r->d[0] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64; |
| 270 | + c += p1 + (uint128_t)SECP256K1_N_C_1 * p4; |
| 271 | + r->d[1] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64; |
| 272 | + c += p2 + (uint128_t)p4; |
| 273 | + r->d[2] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64; |
| 274 | + c += p3; |
| 275 | + r->d[3] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64; |
| 276 | + |
| 277 | + // Final reduction of r. |
| 278 | + secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r)); |
| 279 | +} |
| 280 | + |
| 281 | +void static secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) { |
| 282 | + // 160 bit accumulator. |
| 283 | + uint64_t c0 = 0, c1 = 0; |
| 284 | + uint32_t c2 = 0; |
| 285 | + |
| 286 | + uint64_t l[8]; |
| 287 | + |
| 288 | + // l[0..7] = a[0..3] * b[0..3]. |
| 289 | + muladd_fast(a->d[0], b->d[0]); |
| 290 | + extract_fast(l[0]); |
| 291 | + muladd(a->d[0], b->d[1]); |
| 292 | + muladd(a->d[1], b->d[0]); |
| 293 | + extract(l[1]); |
| 294 | + muladd(a->d[0], b->d[2]); |
| 295 | + muladd(a->d[1], b->d[1]); |
| 296 | + muladd(a->d[2], b->d[0]); |
| 297 | + extract(l[2]); |
| 298 | + muladd(a->d[0], b->d[3]); |
| 299 | + muladd(a->d[1], b->d[2]); |
| 300 | + muladd(a->d[2], b->d[1]); |
| 301 | + muladd(a->d[3], b->d[0]); |
| 302 | + extract(l[3]); |
| 303 | + muladd(a->d[1], b->d[3]); |
| 304 | + muladd(a->d[2], b->d[2]); |
| 305 | + muladd(a->d[3], b->d[1]); |
| 306 | + extract(l[4]); |
| 307 | + muladd(a->d[2], b->d[3]); |
| 308 | + muladd(a->d[3], b->d[2]); |
| 309 | + extract(l[5]); |
| 310 | + muladd_fast(a->d[3], b->d[3]); |
| 311 | + extract_fast(l[6]); |
| 312 | + VERIFY_CHECK(c1 <= 0); |
| 313 | + l[7] = c0; |
| 314 | + |
| 315 | + secp256k1_scalar_reduce_512(r, l); |
| 316 | +} |
| 317 | + |
| 318 | +void static secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) { |
| 319 | + // 160 bit accumulator. |
| 320 | + uint64_t c0 = 0, c1 = 0; |
| 321 | + uint32_t c2 = 0; |
| 322 | + |
| 323 | + uint64_t l[8]; |
| 324 | + |
| 325 | + // l[0..7] = a[0..3] * b[0..3]. |
| 326 | + muladd_fast(a->d[0], a->d[0]); |
| 327 | + extract_fast(l[0]); |
| 328 | + muladd2(a->d[0], a->d[1]); |
| 329 | + extract(l[1]); |
| 330 | + muladd2(a->d[0], a->d[2]); |
| 331 | + muladd(a->d[1], a->d[1]); |
| 332 | + extract(l[2]); |
| 333 | + muladd2(a->d[0], a->d[3]); |
| 334 | + muladd2(a->d[1], a->d[2]); |
| 335 | + extract(l[3]); |
| 336 | + muladd2(a->d[1], a->d[3]); |
| 337 | + muladd(a->d[2], a->d[2]); |
| 338 | + extract(l[4]); |
| 339 | + muladd2(a->d[2], a->d[3]); |
| 340 | + extract(l[5]); |
| 341 | + muladd_fast(a->d[3], a->d[3]); |
| 342 | + extract_fast(l[6]); |
| 343 | + VERIFY_CHECK(c1 == 0); |
| 344 | + l[7] = c0; |
| 345 | + |
| 346 | + secp256k1_scalar_reduce_512(r, l); |
| 347 | +} |
| 348 | + |
| 349 | +#undef sumadd |
| 350 | +#undef sumadd_fast |
| 351 | +#undef muladd |
| 352 | +#undef muladd_fast |
| 353 | +#undef muladd2 |
| 354 | +#undef extract |
| 355 | +#undef extract_fast |
| 356 | + |
| 357 | +#endif |
0 commit comments