2a:I[49813,["/_next/static/chunks/3z--bwudlglfp.js","/_next/static/chunks/2u04xn-9yg2co.js","/_next/static/chunks/1b5-8ftwqgmtb.js","/_next/static/chunks/3nqo6bdos11l6.js","/_next/static/chunks/0fz0mlrjifmq7.js","/_next/static/chunks/034_kq3j28m99.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/3meo7law-jljp.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2b:T431f,/** * Copyright (c) 2011-2026 libbitcoin developers * * This file is part of libbitcoin. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ #ifndef LIBBITCOIN_SYSTEM_INTRINSICS_NEON_128_HPP #define LIBBITCOIN_SYSTEM_INTRINSICS_NEON_128_HPP #include #include #include #if defined(HAVE_NEON) namespace libbitcoin { namespace system { namespace f { /// bitwise primitives /// --------------------------------------------------------------------------- /// 32 bit functions are applied because xint128_t is typed as uint32x4_t. INLINE xint128_t and_(xint128_t a, xint128_t b) NOEXCEPT { return vandq_u32(a, b); } INLINE xint128_t or_(xint128_t a, xint128_t b) NOEXCEPT { return vorrq_u32(a, b); } INLINE xint128_t xor_(xint128_t a, xint128_t b) NOEXCEPT { return veorq_u32(a, b); } INLINE xint128_t not_(xint128_t a) NOEXCEPT { return xor_(a, vdupq_n_u32(-1)); } /// vector primitives /// --------------------------------------------------------------------------- template INLINE xint128_t shr(xint128_t a) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vshrq_n_u8((uint8x16_t)a, B); if constexpr (S == bits) return (xint128_t)vshrq_n_u16((uint16x8_t)a, B); if constexpr (S == bits) return (xint128_t)vshrq_n_u32((uint32x4_t)a, B); if constexpr (S == bits) return (xint128_t)vshrq_n_u64((uint64x2_t)a, B); } template INLINE xint128_t shl(xint128_t a) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vshlq_n_u8((uint8x16_t)a, B); if constexpr (S == bits) return (xint128_t)vshlq_n_u16((uint16x8_t)a, B); if constexpr (S == bits) return (xint128_t)vshlq_n_u32((uint32x4_t)a, B); if constexpr (S == bits) return (xint128_t)vshlq_n_u64((uint64x2_t)a, B); } template INLINE xint128_t ror(xint128_t a) NOEXCEPT { // Half-word rotation is a single element reversal. if constexpr ((S == bits) && (B == bits)) return (xint128_t)vrev16q_u8((uint8x16_t)a); else if constexpr ((S == bits) && (B == bits)) return (xint128_t)vrev32q_u16((uint16x8_t)a); else if constexpr ((S == bits) && (B == bits)) return (xint128_t)vrev64q_u32((uint32x4_t)a); // Otherwise shift-right-insert halves the synthesized rotation cost. else if constexpr (S == bits) return (xint128_t)vsriq_n_u8(vshlq_n_u8((uint8x16_t)a, S - B), (uint8x16_t)a, B); else if constexpr (S == bits) return (xint128_t)vsriq_n_u16(vshlq_n_u16((uint16x8_t)a, S - B), (uint16x8_t)a, B); else if constexpr (S == bits) return (xint128_t)vsriq_n_u32(vshlq_n_u32((uint32x4_t)a, S - B), (uint32x4_t)a, B); else if constexpr (S == bits) return (xint128_t)vsriq_n_u64(vshlq_n_u64((uint64x2_t)a, S - B), (uint64x2_t)a, B); } template INLINE xint128_t rol(xint128_t a) NOEXCEPT { return ror(a); } template INLINE xint128_t add(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vaddq_u8((uint8x16_t)a, (uint8x16_t)b); if constexpr (S == bits) return (xint128_t)vaddq_u16((uint16x8_t)a, (uint16x8_t)b); if constexpr (S == bits) return (xint128_t)vaddq_u32((uint32x4_t)a, (uint32x4_t)b); if constexpr (S == bits) return (xint128_t)vaddq_u64((uint64x2_t)a, (uint64x2_t)b); } template INLINE xint128_t sub(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vsubq_u8((uint8x16_t)a, (uint8x16_t)b); if constexpr (S == bits) return (xint128_t)vsubq_u16((uint16x8_t)a, (uint16x8_t)b); if constexpr (S == bits) return (xint128_t)vsubq_u32((uint32x4_t)a, (uint32x4_t)b); if constexpr (S == bits) return (xint128_t)vsubq_u64((uint64x2_t)a, (uint64x2_t)b); } template INLINE xint128_t addc(xint128_t a) NOEXCEPT { if constexpr (S == bits) return add(a, (xint128_t)vdupq_n_u8((uint8_t)K)); if constexpr (S == bits) return add(a, (xint128_t)vdupq_n_u16((uint16_t)K)); if constexpr (S == bits) return add(a, (xint128_t)vdupq_n_u32((uint32_t)K)); if constexpr (S == bits) return add(a, (xint128_t)vdupq_n_u64((uint64_t)K)); } template = true> INLINE xint128_t add(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (is_same_type) return (xint128_t)vaddq_u8((uint8x16_t)a, (uint8x16_t)b); if constexpr (is_same_type) return (xint128_t)vaddq_u16((uint16x8_t)a, (uint16x8_t)b); if constexpr (is_same_type) return (xint128_t)vaddq_u32((uint32x4_t)a, (uint32x4_t)b); if constexpr (is_same_type) return (xint128_t)vaddq_u64((uint64x2_t)a, (uint64x2_t)b); } template INLINE xint128_t mul(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vmull_u32(vmovn_u64((uint64x2_t)a), vmovn_u64((uint64x2_t)b)); } template INLINE xint128_t madd52lo(xint128_t c, xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vmadd52loq_u64((uint64x2_t)c, (uint64x2_t)a, (uint64x2_t)b); } template INLINE xint128_t madd52hi(xint128_t c, xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vmadd52hiq_u64((uint64x2_t)c, (uint64x2_t)a, (uint64x2_t)b); } /// broadcast/get/set /// --------------------------------------------------------------------------- template = true, if_same = true> INLINE xint128_t broadcast(Word a) NOEXCEPT { if constexpr (is_same_type) return (xint128_t)vdupq_n_u8((uint8_t)a); if constexpr (is_same_type) return (xint128_t)vdupq_n_u16((uint16_t)a); if constexpr (is_same_type) return (xint128_t)vdupq_n_u32((uint32_t)a); if constexpr (is_same_type) return (xint128_t)vdupq_n_u64((uint64_t)a); } // Lane zero is lowest order word. template = true> INLINE Word get(xint128_t a) NOEXCEPT { if constexpr (is_same_type) return (Word)vgetq_lane_u8((uint8x16_t)a, Lane); if constexpr (is_same_type) return (Word)vgetq_lane_u16((uint16x8_t)a, Lane); if constexpr (is_same_type) return (Word)vgetq_lane_u32((uint32x4_t)a, Lane); if constexpr (is_same_type) return (Word)vgetq_lane_u64((uint64x2_t)a, Lane); } // Low order word to the left. template = true> INLINE xint128_t set(uint64_t x01, uint64_t x02) NOEXCEPT { return (xint128_t)vcombine_u64(vcreate_u64(x01), vcreate_u64(x02)); } template = true> INLINE xint128_t set( uint32_t x01, uint32_t x02, uint32_t x03, uint32_t x04) NOEXCEPT { const uint32_t a[]{ x01, x02, x03, x04 }; return (xint128_t)vld1q_u32(a); } template = true> INLINE xint128_t set( uint16_t x01, uint16_t x02, uint16_t x03, uint16_t x04, uint16_t x05, uint16_t x06, uint16_t x07, uint16_t x08) NOEXCEPT { auto low = vcreate_u16( (uint64_t)x02 << 16 | (uint64_t)x01 << 0); low = vset_lane_u16((uint16_t)x03, low, 2); low = vset_lane_u16((uint16_t)x04, low, 3); auto high = vcreate_u16( (uint64_t)x06 << 16 | (uint64_t)x05 << 0); high = vset_lane_u16((uint16_t)x07, high, 2); high = vset_lane_u16((uint16_t)x08, high, 3); return (xint128_t)vcombine_u16(low, high); } template = true> INLINE xint128_t set( uint8_t x01, uint8_t x02, uint8_t x03, uint8_t x04, uint8_t x05, uint8_t x06, uint8_t x07, uint8_t x08, uint8_t x09, uint8_t x10, uint8_t x11, uint8_t x12, uint8_t x13, uint8_t x14, uint8_t x15, uint8_t x16) NOEXCEPT { auto low = vcreate_u8( (uint64_t)x04 << 24 | (uint64_t)x03 << 16 | (uint64_t)x02 << 8 | (uint64_t)x01 << 0); low = vset_lane_u8((uint8_t)x05, low, 4); low = vset_lane_u8((uint8_t)x06, low, 5); low = vset_lane_u8((uint8_t)x07, low, 6); low = vset_lane_u8((uint8_t)x08, low, 7); auto high = vcreate_u8( (uint64_t)x12 << 24 | (uint64_t)x11 << 16 | (uint64_t)x10 << 8 | (uint64_t)x09 << 0); high = vset_lane_u8((uint8_t)x13, high, 4); high = vset_lane_u8((uint8_t)x14, high, 5); high = vset_lane_u8((uint8_t)x15, high, 6); high = vset_lane_u8((uint8_t)x16, high, 7); return (xint128_t)vcombine_u8(low, high); } /// endianness /// --------------------------------------------------------------------------- template = true> INLINE xint128_t byteswap(xint128_t a) NOEXCEPT { return (xint128_t)a; } template = true> INLINE xint128_t byteswap(xint128_t a) NOEXCEPT { return (xint128_t)vrev16q_u8((uint8x16_t)a); } template = true> INLINE xint128_t byteswap(xint128_t a) NOEXCEPT { return (xint128_t)vrev32q_u8((uint8x16_t)a); } template = true> INLINE xint128_t byteswap(xint128_t a) NOEXCEPT { return (xint128_t)vrev64q_u8((uint8x16_t)a); } /// load/store (lanes of Integral from casted, bytes from pointer) /// --------------------------------------------------------------------------- template = true> INLINE xint128_t load(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u8((const uint8_t*)&bytes); } template = true> INLINE xint128_t load(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u16((const uint16_t*)&bytes); } template = true> INLINE xint128_t load(const xint128_t& bytes) NOEXCEPT { return vld1q_u32((const uint32_t*)&bytes); } template = true> INLINE xint128_t load(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u64((const uint64_t*)&bytes); } template = true> INLINE void store(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u8((uint8_t*)&bytes, (uint8x16_t)a); } template = true> INLINE void store(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u16((uint16_t*)&bytes, (uint16x8_t)a); } template = true> INLINE void store(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u32((uint32_t*)&bytes, a); } template = true> INLINE void store(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u64((uint64_t*)&bytes, (uint64x2_t)a); } template = true> INLINE xint128_t load(const uint8_t* bytes) NOEXCEPT { return (xint128_t)vld1q_u8(bytes); } INLINE void store(uint8_t* bytes, xint128_t a) NOEXCEPT { vst1q_u8(bytes, (uint8x16_t)a); } template = true> INLINE xint128_t load_aligned(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u8((const uint8_t*)&bytes); } template = true> INLINE xint128_t load_aligned(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u16((const uint16_t*)&bytes); } template = true> INLINE xint128_t load_aligned(const xint128_t& bytes) NOEXCEPT { return vld1q_u32((const uint32_t*)&bytes); } template = true> INLINE xint128_t load_aligned(const xint128_t& bytes) NOEXCEPT { return (xint128_t)vld1q_u64((const uint64_t*)&bytes); } template = true> INLINE void store_aligned(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u8((uint8_t*)&bytes, (uint8x16_t)a); } template = true> INLINE void store_aligned(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u16((uint16_t*)&bytes, (uint16x8_t)a); } template = true> INLINE void store_aligned(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u32((uint32_t*)&bytes, a); } template = true> INLINE void store_aligned(xint128_t& bytes, xint128_t a) NOEXCEPT { vst1q_u64((uint64_t*)&bytes, (uint64x2_t)a); } /// compare/select /// --------------------------------------------------------------------------- /// Masks are all bits set (true) or unset (false) per word. INLINE xint128_t andnot(xint128_t a, xint128_t b) NOEXCEPT { return vbicq_u32(b, a); } template INLINE xint128_t eq(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vceqq_u8((uint8x16_t)a, (uint8x16_t)b); if constexpr (S == bits) return (xint128_t)vceqq_u16((uint16x8_t)a, (uint16x8_t)b); if constexpr (S == bits) return vceqq_u32(a, b); if constexpr (S == bits) { // A 64 bit word is equal iff both of its 32 bit words are equal. const auto words = vceqq_u32(a, b); return vandq_u32(words, vrev64q_u32(words)); } } INLINE xint128_t select(xint128_t mask, xint128_t a, xint128_t b) NOEXCEPT { return vbslq_u32(mask, a, b); } INLINE bool any(xint128_t a) NOEXCEPT { const auto halves = vorr_u32(vget_low_u32(a), vget_high_u32(a)); return !is_zero(vget_lane_u32(vpmax_u32(halves, halves), 0)); } /// gather /// --------------------------------------------------------------------------- INLINE xint128_t gather(const uint64_t* table, xint128_t index) NOEXCEPT { BC_PUSH_WARNING(NO_POINTER_ARITHMETIC) return set( table[possible_narrow_cast(get(index))], table[possible_narrow_cast(get(index))]); BC_POP_WARNING() } /// interleave (for matrix transposition) /// --------------------------------------------------------------------------- template INLINE xint128_t unpack_lo(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vzipq_u8((uint8x16_t)a, (uint8x16_t)b).val[0]; if constexpr (S == bits) return (xint128_t)vzipq_u16((uint16x8_t)a, (uint16x8_t)b).val[0]; if constexpr (S == bits) return (xint128_t)vzipq_u32((uint32x4_t)a, (uint32x4_t)b).val[0]; if constexpr (S == bits) return (xint128_t)vcombine_u64(vget_low_u64((uint64x2_t)a), vget_low_u64((uint64x2_t)b)); } template INLINE xint128_t unpack_hi(xint128_t a, xint128_t b) NOEXCEPT { if constexpr (S == bits) return (xint128_t)vzipq_u8((uint8x16_t)a, (uint8x16_t)b).val[1]; if constexpr (S == bits) return (xint128_t)vzipq_u16((uint16x8_t)a, (uint16x8_t)b).val[1]; if constexpr (S == bits) return (xint128_t)vzipq_u32((uint32x4_t)a, (uint32x4_t)b).val[1]; if constexpr (S == bits) return (xint128_t)vcombine_u64(vget_high_u64((uint64x2_t)a), vget_high_u64((uint64x2_t)b)); } INLINE xint128_t tile_lo(xint128_t a, xint128_t) NOEXCEPT { return a; } INLINE xint128_t tile_hi(xint128_t, xint128_t b) NOEXCEPT { return b; } } // namespace f } // namespace system } // namespace libbitcoin #endif // HAVE_NEON #endif 13:["$","$L2a",null,{"project":{"id":"cmuidb72x000001s1932ifphv","owner":"libbitcoin","repo":"libbitcoin-system","displayName":"libbitcoin/libbitcoin-system","defaultBranch":"master"},"commit":{"sha":"121d29eceaf821490dfef9f329758891c584ae57","message":"Disable clang-cl warnings in system headers.","authorLogin":"evoskuil","authorName":"Eric Voskuil","date":"2026-10-30T18:12:39.000Z","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/commit/121d29eceaf821490dfef9f329758891c584ae57","isHead":false,"headSha":"876e2e139ded674b405285caa83394aac84953f0"},"gitRef":"121d29eceaf821490dfef9f329758891c584ae57","path":"include/bitcoin/system/intrinsics/neon/neon_128.hpp","target":{"kind":"file","file":{"path":"include/bitcoin/system/intrinsics/neon/neon_128.hpp","size":17183,"content":"$2b","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/121d29eceaf821490dfef9f329758891c584ae57/include/bitcoin/system/intrinsics/neon/neon_128.hpp","mutants":[],"mutantsAtOtherRevisions":0}},"treeCache":{"":[{"name":".github","path":".github","type":"dir","size":null},{"name":".vscode","path":".vscode","type":"dir","size":null},{"name":"builds","path":"builds","type":"dir","size":null},{"name":"doc","path":"doc","type":"dir","size":null},{"name":"include","path":"include","type":"dir","size":null},{"name":"src","path":"src","type":"dir","size":null},{"name":"test","path":"test","type":"dir","size":null},{"name":"tools","path":"tools","type":"dir","size":null},{"name":".gitignore","path":".gitignore","type":"file","size":1037},{"name":"COPYING","path":"COPYING","type":"file","size":33899},{"name":"README.md","path":"README.md","type":"file","size":9650}],"include":[{"name":"bitcoin","path":"include/bitcoin","type":"dir","size":null}],"include/bitcoin":[{"name":"system","path":"include/bitcoin/system","type":"dir","size":null},{"name":"system.hpp","path":"include/bitcoin/system.hpp","type":"file","size":18489}],"include/bitcoin/system":[{"name":"chain","path":"include/bitcoin/system/chain","type":"dir","size":null},{"name":"config","path":"include/bitcoin/system/config","type":"dir","size":null},{"name":"crypto","path":"include/bitcoin/system/crypto","type":"dir","size":null},{"name":"data","path":"include/bitcoin/system/data","type":"dir","size":null},{"name":"endian","path":"include/bitcoin/system/endian","type":"dir","size":null},{"name":"error","path":"include/bitcoin/system/error","type":"dir","size":null},{"name":"filter","path":"include/bitcoin/system/filter","type":"dir","size":null},{"name":"hash","path":"include/bitcoin/system/hash","type":"dir","size":null},{"name":"impl","path":"include/bitcoin/system/impl","type":"dir","size":null},{"name":"intrinsics","path":"include/bitcoin/system/intrinsics","type":"dir","size":null},{"name":"machine","path":"include/bitcoin/system/machine","type":"dir","size":null},{"name":"math","path":"include/bitcoin/system/math","type":"dir","size":null},{"name":"radix","path":"include/bitcoin/system/radix","type":"dir","size":null},{"name":"serial","path":"include/bitcoin/system/serial","type":"dir","size":null},{"name":"stream","path":"include/bitcoin/system/stream","type":"dir","size":null},{"name":"unicode","path":"include/bitcoin/system/unicode","type":"dir","size":null},{"name":"wallet","path":"include/bitcoin/system/wallet","type":"dir","size":null},{"name":"words","path":"include/bitcoin/system/words","type":"dir","size":null},{"name":"x509","path":"include/bitcoin/system/x509","type":"dir","size":null},{"name":"allocator.hpp","path":"include/bitcoin/system/allocator.hpp","type":"file","size":9990},{"name":"arena.hpp","path":"include/bitcoin/system/arena.hpp","type":"file","size":4397},{"name":"boost.hpp","path":"include/bitcoin/system/boost.hpp","type":"file","size":2549},{"name":"constants.hpp","path":"include/bitcoin/system/constants.hpp","type":"file","size":7217},{"name":"constraints.hpp","path":"include/bitcoin/system/constraints.hpp","type":"file","size":8213},{"name":"define.hpp","path":"include/bitcoin/system/define.hpp","type":"file","size":1861},{"name":"exceptions.hpp","path":"include/bitcoin/system/exceptions.hpp","type":"file","size":2544},{"name":"execution.hpp","path":"include/bitcoin/system/execution.hpp","type":"file","size":10757},{"name":"forks.hpp","path":"include/bitcoin/system/forks.hpp","type":"file","size":2593},{"name":"funclets.hpp","path":"include/bitcoin/system/funclets.hpp","type":"file","size":5883},{"name":"have.hpp","path":"include/bitcoin/system/have.hpp","type":"file","size":13094},{"name":"literals.hpp","path":"include/bitcoin/system/literals.hpp","type":"file","size":6680},{"name":"preprocessor.hpp","path":"include/bitcoin/system/preprocessor.hpp","type":"file","size":7292},{"name":"settings.hpp","path":"include/bitcoin/system/settings.hpp","type":"file","size":4769},{"name":"typelets.hpp","path":"include/bitcoin/system/typelets.hpp","type":"file","size":7846},{"name":"types.hpp","path":"include/bitcoin/system/types.hpp","type":"file","size":12018},{"name":"version.hpp.in","path":"include/bitcoin/system/version.hpp.in","type":"file","size":1041},{"name":"warnings.hpp","path":"include/bitcoin/system/warnings.hpp","type":"file","size":4555}],"include/bitcoin/system/intrinsics":[{"name":"intel","path":"include/bitcoin/system/intrinsics/intel","type":"dir","size":null},{"name":"neon","path":"include/bitcoin/system/intrinsics/neon","type":"dir","size":null},{"name":"none","path":"include/bitcoin/system/intrinsics/none","type":"dir","size":null},{"name":"sve","path":"include/bitcoin/system/intrinsics/sve","type":"dir","size":null},{"name":"add.hpp","path":"include/bitcoin/system/intrinsics/add.hpp","type":"file","size":3058},{"name":"byte_swap.hpp","path":"include/bitcoin/system/intrinsics/byte_swap.hpp","type":"file","size":4065},{"name":"count.hpp","path":"include/bitcoin/system/intrinsics/count.hpp","type":"file","size":1857},{"name":"cpuid.hpp","path":"include/bitcoin/system/intrinsics/cpuid.hpp","type":"file","size":6568},{"name":"detection.hpp","path":"include/bitcoin/system/intrinsics/detection.hpp","type":"file","size":10667},{"name":"intrinsics.hpp","path":"include/bitcoin/system/intrinsics/intrinsics.hpp","type":"file","size":2033},{"name":"multiply.hpp","path":"include/bitcoin/system/intrinsics/multiply.hpp","type":"file","size":4448},{"name":"rotate.hpp","path":"include/bitcoin/system/intrinsics/rotate.hpp","type":"file","size":3827},{"name":"types.hpp","path":"include/bitcoin/system/intrinsics/types.hpp","type":"file","size":5997}],"include/bitcoin/system/intrinsics/neon":[{"name":"neon_128.hpp","path":"include/bitcoin/system/intrinsics/neon/neon_128.hpp","type":"file","size":17183},{"name":"neon_aes.hpp","path":"include/bitcoin/system/intrinsics/neon/neon_aes.hpp","type":"file","size":7263},{"name":"neon_sha.hpp","path":"include/bitcoin/system/intrinsics/neon/neon_sha.hpp","type":"file","size":5779},{"name":"neon.hpp","path":"include/bitcoin/system/intrinsics/neon/neon.hpp","type":"file","size":2431}]},"revisions":[{"commitSha":"c37c9b73278f1f97e6eb6421f3544f5e58edba2f","branch":null,"commitMessage":"Merge pull request #2132 from evoskuil/master","commitDate":"2026-10-29T20:40:10.000Z","mutantCount":36},{"commitSha":"9fa0f9a07f31c5cc9ebe5efa05e6d4a6d12ba183","branch":null,"commitMessage":"Test script pattern length guards and the sixteen key multisig builder boundary.","commitDate":"2026-09-29T18:05:00.000Z","mutantCount":129},{"commitSha":"98db5bfd7c7b65532e42309c7b71419d82ec5ea8","branch":null,"commitMessage":"Merge pull request #2017 from evoskuil/master","commitDate":"2026-09-28T17:24:16.000Z","mutantCount":230},{"commitSha":"827fb29d0fecbdf7a157e05b1bea59bc916787aa","branch":null,"commitMessage":"Test multisig sighash cache reset across distinct subscripts","commitDate":"2026-09-26T12:24:47.000Z","mutantCount":1},{"commitSha":"8e7a9fdcb4ca72bc5bfe9961815aaa9bc33b64a0","branch":null,"commitMessage":"Remove dead include.","commitDate":"2026-09-25T06:52:28.000Z","mutantCount":90}],"signedIn":false,"pullRequest":{"id":"cmvwrgy0h00ex01n1ycl8rckj","number":2134,"title":"Expanded CI coverage. (clang-cl, Arm, mac x64).","headSha":"121d29eceaf821490dfef9f329758891c584ae57","state":"MERGED","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/pull/2134","ranges":[[474,474],[476,476],[478,478],[480,481],[488,488],[490,490],[492,492],[494,495]],"fileInDiff":true,"atHead":true}}]