Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
bignSeedInc
static void bignSeedInc(octet seed[8]) { register word carry; size_t pos; ASSERT(memIsValid(seed, 8)); for (carry = 1, pos = 0; pos < 8; ++pos) carry += seed[pos], seed[pos] = (octet)carry, carry >>= 8; carry = 0; }
pushq $0x1 popq %rax xorl %ecx, %ecx cmpq $0x8, %rcx je 0x2c78c movzbl (%rdi,%rcx), %edx addq %rdx, %rax movb %al, (%rdi,%rcx) shrq $0x8, %rax incq %rcx jmp 0x2c773 retq
/agievich[P]bee2/src/crypto/bign/bign_params.c
ecpDetIsZero
bool_t ecpDetIsZero(const word a[], const word b[], const word p[], size_t n, void* stack) { // переменные в stack word* t1 = (word*)stack; word* t2 = t1 + n; stack = t2 + n; // t1 <- 4 A^3 zzSqrMod(t1, a, p, n, stack); zzMulMod(t1, t1, a, p, n, stack); zzMulWMod(t1, t1, 4, p, n, stack); // t2 <- 27 B^2 zzS...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %rbx movq %rdx, %r15 movq %rsi, (%rsp) movq %rdi, %rbp leaq (%r8,%rcx,8), %r12 leaq (%r12,%rcx,8), %r13 movq %r8, %rdi movq %rbp, %rsi movq %r13, %r8 callq 0xe030 movq %r14, %rdi movq %r14, %rsi movq %rbp, %rdx movq %...
/agievich[P]bee2/src/crypto/bign/bign_params.c
ecpDetIsZero_deep
size_t ecpDetIsZero_deep(size_t n) { return O_OF_W(2 * n) + utilMax(3, zzSqrMod_deep(n), zzMulMod_deep(n), zzMulWMod_deep(n) ); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq %rdi, %r12 shlq $0x4, %r12 callq 0xea60 movq %rax, %r14 movq %rbx, %rdi callq 0xe0b0 movq %rax, %r15 movq %rbx, %rdi callq 0xf500 pushq $0x3 popq %rdi movq %r14, %rsi movq %r15, %rdx movq %rax, %rcx xorl %eax, %eax callq 0xe320 addq %r12, %rax ...
/agievich[P]bee2/src/crypto/bign/bign_params.c
ecpMOVIsMet
bool_t ecpMOVIsMet(const word q[], const word p[], size_t n, size_t threshold, void* stack) { // переменные в stack word* t1 = (word*)stack; word* t2 = t1 + n; stack = t2 + n; // t1, t2 <- p mod q ASSERT(threshold > 0); zzMod(t1, p, n, q, n, stack); wwCopy(t2, t1, n); // p mod q == 1? if (wwCmpW(t2, n, 1) =...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %rbx movq %rcx, %r14 movq %rdx, %r15 movq %rdi, %r12 leaq (%r8,%rdx,8), %r13 leaq (%r13,%rdx,8), %rbp movq %r8, %rdi movq %r12, %rcx movq %rdx, %r8 movq %rbp, %r9 callq 0xfc00 movq %r13, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0xe...
/agievich[P]bee2/src/crypto/bign/bign_params.c
bignParamsGen
err_t bignParamsGen(bign_params* params, bign_pgen_calc_q calc_q, bign_pgen_on_seed on_seed, void* state) { err_t code; size_t no, n; // состояние (буферы могут пересекаться) void* st; word* p; /* [n] */ word* a; /* [n] */ word* b; /* [W_OF_B(512)] B / [n] b */ word* q; /* [n] */ word* yG; /* [...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movl $0x150, %esi # imm = 0x150 callq 0xeeb0 pushq $0x6d popq %rbp testq %r13, %r13 je 0x2ca15 testl %eax, %eax je 0x2ca15 movq (%rbx), %r14 movl $0x1f6, %ebp ...
/agievich[P]bee2/src/crypto/bign/bign_params.c
bignParamsEnc
err_t bignParamsEnc(octet der[], size_t* count, const bign_params* params) { size_t len; if (!memIsValid(params, sizeof(bign_params)) || !memIsValid(count, O_PER_S) || !memIsNullOrValid(der, *count)) return ERR_BAD_INPUT; if (!bignIsOperable(params)) return ERR_BAD_PARAMS; len = bignParamsEnc_internal(0, pa...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r15 movl $0x150, %esi # imm = 0x150 movq %rdx, %rdi callq 0xeeb0 pushq $0x6d popq %rbp testl %eax, %eax je 0x2cf38 pushq $0x8 popq %rsi movq %rbx, %rdi callq 0xeeb0 testl %eax, %eax je 0x2cf38 testq %r15, %r15 ...
/agievich[P]bee2/src/crypto/bign/bign_params.c
bignParamsEnc_internal
static size_t bignParamsEnc_internal(octet der[], const bign_params* params) { der_anchor_t ParamSeq[1]; der_anchor_t FieldSeq[1]; der_anchor_t CurveSeq[1]; size_t count = 0; // начать кодирование... derEncStep(derSEQEncStart(ParamSeq, der, count), der, count); // ...version... derEncStep(derSIZEEnc(der, 1), ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rsi, %r14 movq %rdi, %r12 leaq 0x40(%rsp), %rdi pushq $0x30 popq %rcx movq %r12, %rsi xorl %edx, %edx callq 0xf200 movq %rax, %r13 leaq (%r12,%rax), %rbx testq %r12, %r12 cmoveq %r12, %rbx pushq $0x2 popq %r12 pushq $0x1 popq %rdx ...
/agievich[P]bee2/src/crypto/bign/bign_params.c
bignParamsDec
err_t bignParamsDec(bign_params* params, const octet der[], size_t count) { size_t len; if (!memIsValid(params, sizeof(bign_params)) || !memIsValid(der, count)) return ERR_BAD_INPUT; len = bignParamsDec_internal(params, der, count); if (len == SIZE_MAX || len != count) return ERR_BAD_FORMAT; return ERR_OK; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x150, %esi # imm = 0x150 callq 0xeeb0 pushq $0x6d popq %rbp testl %eax, %eax je 0x2d440 movq %r14, %rdi movq %rbx, %rsi callq 0xeeb0 testl %eax, %eax je 0x2d440 movq $0x20...
/agievich[P]bee2/src/crypto/bign/bign_params.c
bignSign
err_t bignSign(octet sig[], const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[], const octet privkey[], gen_i rng, void* rng_state) { err_t code; size_t no, n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ word* d; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r9, %r12 movq %r8, %r14 movq %rcx, %rbp movq %rdx, %r13 movq %rsi, %rbx movq %rdi, %r15 movl $0x150, %esi # imm = 0x150 movq %rbx, %rdi callq 0xeeb0 testl %eax, %eax je 0x2d79d movq %rbx, %rdi callq 0x101d0 testl %eax, %...
/agievich[P]bee2/src/crypto/bign/bign_sign.c
bignSign2
err_t bignSign2(octet sig[], const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[], const octet privkey[], const void* t, size_t t_len) { err_t code; size_t no, n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ word* d; /...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r9, %rbp movq %r8, 0x10(%rsp) movq %rcx, %r12 movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r13 movl $0x150, %esi # imm = 0x150 movq %rbx, %rdi callq 0xeeb0 pushq $0x6d popq %r14 testl %eax, %eax je 0x2d932 movq %rbx, %rdi...
/agievich[P]bee2/src/crypto/bign/bign_sign.c
bignVerify
err_t bignVerify(const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[], const octet sig[], const octet pubkey[]) { err_t code; size_t no, n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ word* Q; /* [2n] открытый ключ */ w...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r9, %r13 movq %r8, %rbp movq %rcx, %r14 movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx movl $0x150, %esi # imm = 0x150 callq 0xeeb0 testl %eax, %eax je 0x2e059 movq %rbx, %rdi callq 0x101d0 testl %eax, %eax je 0x2e05e m...
/agievich[P]bee2/src/crypto/bign/bign_sign.c
bign96ParamsStd
err_t bign96ParamsStd(bign_params* params, const char* name) { if (!memIsValid(params, sizeof(bign_params))) return ERR_BAD_INPUT; if (strEq(name, _curve96v1_name)) { params->l = 96; memCopy(params->p, _curve96v1_p, 24); memCopy(params->a, _curve96v1_a, 24); memCopy(params->seed, _curve96v1_seed, 8); mem...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl $0x150, %esi # imm = 0x150 callq 0xeeb0 testl %eax, %eax je 0x2e1be leaq 0x21329(%rip), %rsi # 0x4f440 movq %r14, %rdi callq 0xebd0 movl %eax, %ecx movl $0xca, %eax testl %ecx, %ecx jne 0x2e1c1 movq $0x60, (%rbx) leaq 0x8(%rbx), %rdi l...
/agievich[P]bee2/src/crypto/bign96.c
bign96Start_keep
size_t bign96Start_keep(bign96_deep_i deep) { // размерности size_t n = W_OF_B(192); size_t f_keep = gfpCreate_keep(24); size_t f_deep = gfpCreate_deep(24); size_t ec_d = 3; size_t ec_keep = ecpCreateJ_keep(n); size_t ec_deep = ecpCreateJ_deep(n, f_deep); // расчет return f_keep + ec_keep + utilMax(3, ec_...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r15 pushq $0x18 popq %rbx movq %rbx, %rdi callq 0x10050 movq %rax, %r14 movq %rbx, %rdi callq 0xefd0 movq %rax, %rbp pushq $0x3 popq %r12 movq %r12, %rdi callq 0x10180 movq %rax, %rbx movq %r12, %rdi movq %rbp, %rsi callq 0xfb00 mo...
/agievich[P]bee2/src/crypto/bign96.c
bign96ParamsVal
err_t bign96ParamsVal(const bign_params* params) { err_t code; size_t n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ octet* hash_state; /* [beltHash_keep] состояние хэширования */ octet* hash_data; /* [8] данные хэширования */ word* B; /* [W_OF_B(5...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r13 movl $0x150, %esi # imm = 0x150 callq 0xeeb0 testl %eax, %eax je 0x2e3d0 movl $0x1f6, %ebp # imm = 0x1F6 cmpq $0x60, (%r13) jne 0x2e3d7 leaq 0x293(%rip), %rdi # 0x2e633 callq 0xf4e0 movq %rax, ...
/agievich[P]bee2/src/crypto/bign96.c
bign96KeypairVal
err_t bign96KeypairVal(const bign_params* params, const octet privkey[24], const octet pubkey[48]) { err_t code; size_t n; // состояние void* state; ec_o* ec; /* описание эллиптической кривой */ word* d; /* [n] личный ключ */ word* Q; /* [2n] открытый ключ */ void* stack; // проверить params if (!me...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r12 movq %rdi, %r15 movl $0x150, %esi # imm = 0x150 callq 0xeeb0 testl %eax, %eax je 0x2e8fc movl $0x1f6, %ebp # imm = 0x1F6 cmpq $0x60, (%r15) jne 0x2e903 leaq 0x140(%rip), %rdi # 0x2ea0...
/agievich[P]bee2/src/crypto/bign96.c
bign96PubkeyCalc
err_t bign96PubkeyCalc(octet pubkey[48], const bign_params* params, const octet privkey[24]) { err_t code; size_t n; // состояние void* state; ec_o* ec; /* описание эллиптической кривой */ word* d; /* [n] личный ключ */ word* Q; /* [2n] открытый ключ */ void* stack; // проверить params if (!memIsVal...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movq %rsi, %r15 movq %rdi, %rbx movl $0x150, %esi # imm = 0x150 movq %r15, %rdi callq 0xeeb0 testl %eax, %eax je 0x2eb96 movl $0x1f6, %ebp # imm = 0x1F6 cmpq $0x60, (%r15) jne 0x2eb9d leaq 0x11e(%rip), %rd...
/agievich[P]bee2/src/crypto/bign96.c
bign96Sign
err_t bign96Sign(octet sig[34], const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[24], const octet privkey[24], gen_i rng, void* rng_state) { err_t code; size_t n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ word* d; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r9, %r12 movq %r8, %r14 movq %rcx, %r13 movq %rdx, %rbp movq %rsi, %rbx movq %rdi, %r15 movl $0x150, %esi # imm = 0x150 movq %rbx, %rdi callq 0xeeb0 testl %eax, %eax je 0x2ef9b movq %r14, 0x10(%rsp) movl $0x1f6, %r14d ...
/agievich[P]bee2/src/crypto/bign96.c
bign96Sign_deep
static size_t bign96Sign_deep(size_t n, size_t f_deep, size_t ec_d, size_t ec_deep) { return O_OF_W(3 * n + 2 * W_OF_O(13)) + utilMax(4, beltHash_keep(), ecMulA_deep(n, ec_d, ec_deep, n), zzMul_deep(W_OF_O(13), n), zzMod_deep(n + W_OF_O(13), n)); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rcx, %rbx movq %rdx, %r14 movq %rdi, %r15 imulq $0x18, %rdi, %r13 xorl %eax, %eax callq 0xe560 movq %rax, %r12 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx movq %r15, %rcx callq 0xfa10 movq %rax, %rbx pushq $0x2 popq %rdi movq %r15, %rsi callq 0xfe10 movq ...
/agievich[P]bee2/src/crypto/bign96.c
bign96Sign2
err_t bign96Sign2(octet sig[34], const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[24], const octet privkey[24], const void* t, size_t t_len) { err_t code; size_t n; u32 round = 1; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической криво...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %r9, %r12 movq %r8, %rbp movq %rcx, %r13 movq %rdx, %r14 movq %rsi, %rbx movq %rdi, 0x38(%rsp) movl $0x150, %esi # imm = 0x150 movq %rbx, %rdi callq 0xeeb0 pushq $0x6d popq %r15 testl %eax, %eax je 0x2f118 movq %rbp, 0x20...
/agievich[P]bee2/src/crypto/bign96.c
bign96Sign2_deep
static size_t bign96Sign2_deep(size_t n, size_t f_deep, size_t ec_d, size_t ec_deep) { return O_OF_W(3 * n + 2 * W_OF_O(13)) + beltHash_keep() + utilMax(6, beltHash_keep(), 32, beltKWP_keep(), ecMulA_deep(n, ec_d, ec_deep, n), zzMul_deep(W_OF_O(13), n), zzMod_deep(n + W_OF_O(13), n)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r13 movq %rdx, %rbp movq %rdi, %r14 imulq $0x18, %rdi, %r15 xorl %eax, %eax callq 0xe560 movq %rax, %rbx addq %r15, %rbx xorl %eax, %eax callq 0xe560 movq %rax, %r15 xorl %eax, %eax callq 0xf030 movq %rax, %r12 movq %r14, %rdi movq...
/agievich[P]bee2/src/crypto/bign96.c
bign96Verify
err_t bign96Verify(const bign_params* params, const octet oid_der[], size_t oid_len, const octet hash[24], const octet sig[34], const octet pubkey[48]) { err_t code; size_t n; // состояние (буферы могут пересекаться) void* state; ec_o* ec; /* описание эллиптической кривой */ word* Q; /* [2n] открытый ключ ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r9, %r13 movq %r8, %rbp movq %rcx, %r14 movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx movl $0x150, %esi # imm = 0x150 callq 0xeeb0 testl %eax, %eax je 0x2f89c movq %rbp, 0x8(%rsp) movl $0x1f6, %ebp # imm = 0...
/agievich[P]bee2/src/crypto/bign96.c
bpkiPrivkeyWrap
err_t bpkiPrivkeyWrap(octet epki[], size_t* epki_len, const octet privkey[], size_t privkey_len, const octet pwd[], size_t pwd_len, const octet salt[8], size_t iter) { size_t pki_len, edata_len, count; octet* key; err_t code; // проверить входные данные if (iter < 10000) return ERR_BAD_INPUT; if (privkey_len ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp pushq $0x6d popq %rax cmpq $0x2710, 0x68(%rsp) # imm = 0x2710 jae 0x2f954 movl %eax, %r14d jmp 0x2fb32 movq %rcx, %r12 movq %rdi, 0x18(%rsp) leaq -0x18(%rcx), %rax rolq $0x3d, %rax movl $0x1f8, %r14d # imm = 0x1F8 cmpq $0x5...
/agievich[P]bee2/src/crypto/bpki.c
bpkiCSRRewrap
err_t bpkiCSRRewrap(octet csr[], size_t csr_len, const octet privkey[], size_t privkey_len) { err_t code; size_t count; bpki_csr_info_t ci[1]; bign_params params[1]; octet oid_der[16]; size_t oid_len = sizeof(oid_der); octet* hash; // входной контроль if (privkey_len != 32) return ERR_NOT_IMPLEMENTED; if (...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x198, %rsp # imm = 0x198 movq $0x10, 0x8(%rsp) cmpq $0x20, %rcx jne 0x30e56 movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx callq 0xeeb0 pushq $0x6d popq %rbp testl %eax, %eax je 0x30e59 pushq $0x20 popq %rsi movq %r14, %rdi callq 0xeeb0 testl %eax, %eax je ...
/agievich[P]bee2/src/crypto/bpki.c
stb99ParamsVal
err_t stb99ParamsVal(const stb99_params* params) { size_t n, no; size_t m, mo; // состояние void* state; word* p; word* q; word* t; word* d; word* a; qr_o* qr; void* stack; // проверить указатели if (!memIsValid(params, sizeof(stb99_params))) return ERR_BAD_INPUT; // проверить размерности for (n = 0; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx movl $0x3d0, %esi # imm = 0x3D0 callq 0xeeb0 testl %eax, %eax je 0x399a9 movq (%rbx), %r14 xorl %eax, %eax leaq 0x17152(%rip), %rcx # 0x50ae0 movl $0x1f6, %ebp # imm = 0x1F6 cmpq $0x50, %rax je 0...
/agievich[P]bee2/src/crypto/stb99.c
pfokMTI
err_t pfokMTI(octet sharekey[], const pfok_params* params, const octet privkey[], const octet privkey1[], const octet pubkey[], const octet pubkey1[]) { size_t n, no; size_t m, mo; // состояние void* state; word* x; /* [m] личный ключ */ word* u; /* [m] одноразовый личный ключ */ word* y; /* [n] отк...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r9, %rbp movq %r8, 0x58(%rsp) movq %rcx, %r15 movq %rdx, %r13 movq %rsi, %r14 movq %rdi, %rbx movl $0x2f8, %esi # imm = 0x2F8 movq %r14, %rdi callq 0xeeb0 pushq $0x6d popq %r12 testl %eax, %eax je 0x3b451 movq %r14, %rdi...
/agievich[P]bee2/src/crypto/pfok.c
ecIsOperable2
bool_t ecIsOperable2(const ec_o* ec) { return objIsOperable2(ec) && objKeep(ec) >= sizeof(ec_o) && objPCount(ec) == 6 && objOCount(ec) == 1 && wwIsValid(ec->A, ec->f->n) && wwIsValid(ec->B, ec->f->n) && ec->d >= 3 && ec->froma != 0 && ec->toa != 0 && ec->neg != 0 && ec->add != 0 && ec->adda !...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 callq 0xe7d0 xorl %ebx, %ebx testl %eax, %eax je 0x3b52c cmpq $0xb0, (%r14) jb 0x3b52c cmpq $0x6, 0x8(%r14) jne 0x3b52c cmpq $0x1, 0x10(%r14) jne 0x3b52c movq 0x18(%r14), %rax movq 0x20(%r14), %rdi movq 0x30(%rax), %rsi shlq $0x3, %rsi callq 0xeeb0 testl %eax, %eax je 0x...
/agievich[P]bee2/src/math/ec.c
ecCreateGroup
bool_t ecCreateGroup(ec_o* ec, const octet xbase[], const octet ybase[], const octet order[], size_t order_len, u32 cofactor, void* stack) { ASSERT(ecIsOperable(ec)); ASSERT(memIsValid(order, order_len)); ASSERT(memIsNullOrValid(xbase, ec->f->no)); ASSERT(memIsNullOrValid(ybase, ec->f->no)); // корректное описан...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %r9d, %r13d movq %rcx, %r14 movq %rdx, 0x10(%rsp) movq %rsi, %rbp movq %rdi, %rbx movq %rcx, %rdi movq %r8, %rsi callq 0xf8d0 xorl %r12d, %r12d testq %rax, %rax je 0x3b680 testl %r13d, %r13d je 0x3b680 movq %rax, %r15 movl %r13d, 0x...
/agievich[P]bee2/src/math/ec.c
ecIsOperableGroup
bool_t ecIsOperableGroup(const ec_o* ec) { ASSERT(ecIsOperable(ec)); return wwIsValid(ec->base, 2 * ec->f->n) && wwIsValid(ec->order, ec->f->n + 1) && !wwIsZero(ec->order, ec->f->n + 1) && ec->cofactor != 0; }
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x18(%rdi), %rax movq 0x30(%rdi), %rdi movq 0x30(%rax), %rsi shlq $0x4, %rsi callq 0xeeb0 xorl %ebp, %ebp testl %eax, %eax je 0x3b6f7 movq 0x18(%rbx), %rax movq 0x38(%rbx), %rdi movq 0x30(%rax), %rax leaq 0x8(,%rax,8), %rsi callq 0xeeb0 testl %eax, %eax je 0x3b6f7 m...
/agievich[P]bee2/src/math/ec.c
ecMulA_deep
size_t ecMulA_deep(size_t n, size_t ec_d, size_t ec_deep, size_t m) { const size_t naf_width = ecNAFWidth(B_OF_W(m)); const size_t naf_count = SIZE_1 << (naf_width - 2); return O_OF_W(2 * m + 1) + O_OF_W(ec_d * n) + O_OF_W(ec_d * n * naf_count) + ec_deep; }
movq %rcx, %rax shlq $0x6, %rcx cmpq $0x14f, %rcx # imm = 0x14F jbe 0x3b9f5 pushq $0x4 jmp 0x3b9fd cmpq $0x77, %rcx jbe 0x3ba00 pushq $0x3 popq %rcx jmp 0x3ba0b cmpq $0x1, %rcx pushq $0x2 popq %rcx sbbq $0x0, %rcx shlq $0x4, %rax imulq %rdi, %rsi movq %rsi, %rdi shlq %cl, %rdi addq %rsi, %rdi addq %rax, %rdx...
/agievich[P]bee2/src/math/ec.c
ecAddMulA_deep
size_t ecAddMulA_deep(size_t n, size_t ec_d, size_t ec_deep, size_t k, ...) { size_t i, ret; va_list marker; ret = O_OF_W(ec_d * n); ret += 4 * sizeof(size_t) * k; ret += 2 * sizeof(word**) * k; va_start(marker, k); for (i = 0; i < k; ++i) { size_t m = va_arg(marker, size_t); size_t naf_width = ecNAFWidth(B...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rcx, %r10 leaq -0x60(%rsp), %r11 movq %r8, 0x20(%r11) movq %r9, 0x28(%r11) testb %al, %al je 0x3c004 movaps %xmm0, -0x30(%rsp) movaps %xmm1, -0x20(%rsp) movaps %xmm2, -0x10(%rsp) movaps %xmm3, (%rsp) movaps %xmm4, 0x10(%rsp) movaps %xmm5, 0x20(%rsp) mov...
/agievich[P]bee2/src/math/ec.c
ec2CreateLD
bool_t ec2CreateLD(ec_o* ec, const qr_o* f, const octet A[], const octet B[], void* stack) { ASSERT(memIsValid(ec, sizeof(ec_o))); ASSERT(gf2IsOperable(f)); ASSERT(memIsValid(A, f->no)); ASSERT(memIsValid(B, f->no)); // обнулить memSetZero(ec, sizeof(ec_o)); // зафикисровать размерности ec->d = 3; // запомнит...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r15 movq %rcx, %r12 movq %rdx, %r13 movq %rsi, %r14 movq %rdi, %rbx xorl %ebp, %ebp movl $0xb0, %edx xorl %esi, %esi callq 0xf710 movq $0x3, 0x48(%rbx) movq %r14, 0x18(%rbx) leaq 0xb0(%rbx), %rdi movq %rdi, 0x20(%rbx) movq 0x30(%r14...
/agievich[P]bee2/src/math/ec2.c
ec2ToALD
static bool_t ec2ToALD(word b[], const word a[], const ec_o* ec, void* stack) { const size_t n = ec->f->n; // переменные в stack word* t1 = (word*)stack; stack = t1 + n; // pre ASSERT(ecIsOperable(ec) && ec->d == 3); ASSERT(ec2SeemsOn3(a, ec)); ASSERT(a == b || wwIsDisjoint2(a, 3 * n, b, 2 * n)); // a == O => ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r12 movq %rdi, 0x10(%rsp) movq 0x18(%rdx), %rax movq 0x30(%rax), %r13 leaq (%rsi,%r13,8), %r15 leaq (%r15,%r13,8), %rbp movq %rbp, %rdi movq %r13, %rsi callq 0xffc0 movl %eax, %ecx xorl %eax, %...
/agievich[P]bee2/src/math/ec2.c
ec2NegLD
static void ec2NegLD(word b[], const word a[], const ec_o* ec, void* stack) { const size_t n = ec->f->n; // переменные в stack word* t1 = (word*)stack; stack = t1 + n; // pre ASSERT(ecIsOperable(ec) && ec->d == 3); ASSERT(ec2SeemsOn3(a, ec)); ASSERT(wwIsSameOrDisjoint(a, b, 3 * n)); // t1 <- xa * za qrMul(t1,...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 movq 0x18(%rdx), %rcx movq 0x30(%rcx), %r13 leaq (%rbx,%r13,8), %r8 leaq (%rsi,%r13,8), %rax leaq (%rax,%r13,8), %rdx movq %rbx, %rdi callq *0x68(%rcx) leaq (,%r13,2), %rdx addq %r13, %rdx movq %r12, %...
/agievich[P]bee2/src/math/ec2.c
ec2AddLD
static void ec2AddLD(word c[], const word a[], const word b[], const ec_o* ec, void* stack) { const size_t n = ec->f->n; // переменные в stack word* t1 = (word*)stack; word* t2 = t1 + n; word* t3 = t2 + n; word* t4 = t3 + n; word* t5 = t4 + n; word* t6 = t5 + n; stack = t6 + n; // pre ASSERT(ecIsOperable(ec...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r8, 0x30(%rsp) movq %rcx, %r14 movq %rdx, 0x8(%rsp) movq %rsi, %r15 movq %rdi, %rbp movq 0x18(%rcx), %rax movq 0x30(%rax), %r13 leaq (%rsi,%r13,8), %r12 leaq (%r12,%r13,8), %rbx movq %rbx, %rdi movq %r13, %rsi callq 0xffc0 testl %e...
/agievich[P]bee2/src/math/ec2.c
ec2AddALD
static void ec2AddALD(word c[], const word a[], const word b[], const ec_o* ec, void* stack) { const size_t n = ec->f->n; // переменные в stack word* t1 = (word*)stack; word* t2 = t1 + n; word* t3 = t2 + n; word* t4 = t3 + n; stack = t4 + n; // pre ASSERT(ecIsOperable(ec) && ec->d == 3); ASSERT(ec2SeemsOn3(a...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r8, 0x28(%rsp) movq %rcx, %rbx movq %rdx, %r12 movq %rdi, %rbp movq 0x18(%rcx), %rax movq 0x30(%rax), %r15 movq %rsi, 0x18(%rsp) leaq (%rsi,%r15,8), %r14 leaq (%r14,%r15,8), %r13 movq %r13, %rdi movq %r15, %rsi callq 0xffc0 movq 0x...
/agievich[P]bee2/src/math/ec2.c
gf2IsOperable
bool_t gf2IsOperable(const qr_o* f) { const size_t* p; size_t n1; if (!qrIsOperable(f) || !memIsValid(f->params, 4 * sizeof(size_t))) return FALSE; // проверить описание многочлена p = (size_t*)f->params; if (p[0] <= p[1] || p[1] < p[2] || p[2] < p[3] || (p[2] > 0 && (p[1] == p[2] || p[2] == p[3] || p[3] =...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %r14 callq 0xe7c0 xorl %ebx, %ebx testl %eax, %eax je 0x40f8c movq 0x28(%r14), %rdi pushq $0x20 popq %rsi callq 0xeeb0 testl %eax, %eax je 0x40f8c movq 0x28(%r14), %rsi movq (%rsi), %rax movq 0x8(%rsi), %rcx cmpq %rcx, %rax jbe 0x40f8c movq 0x10(%rsi), %rdx cmpq %rdx, %rcx jb...
/agievich[P]bee2/src/math/gf2.c
gauden_alloc_param_full
vector_t **** gauden_alloc_param_full(uint32 n_cb, uint32 n_feat, uint32 n_density, const uint32 *veclen) { uint32 blksize, maxveclen; vector_t ****param; float32 *buf; uint32 i, j, k, l, m; for (blksize = 0, maxveclen = 0, j = 0; j < n_feat; j++) { blksize += veclen[j]; if (veclen[j] > ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %rbx movl %edx, %ebp movl %esi, %r15d movl %esi, 0xc(%rsp) testl %esi, %esi je 0x128b4 xorl %eax, %eax xorl %r12d, %r12d xorl %ecx, %ecx movl (%rbx,%rax,4), %edx addl %edx, %r12d cmpl %ecx, %edx cmoval %edx, %ecx incq %rax cmp...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
gauden_mixture
float64 gauden_mixture(float64 **den, uint32 **den_idx, float32 **w, gauden_t *g) { float64 out; uint32 j; out = 1.0; for (j = 0; j < g->n_feat; j++) { uint32 kk; float64 oprob; oprob = 0; kk = 0; while (kk < g->n_top) { uint32 k; k = den_idx[j][kk]; oprob ...
pushq %r14 pushq %rbx movl (%rcx), %eax testq %rax, %rax je 0x14560 movl 0x18(%rcx), %ecx movsd 0xeaf5(%rip), %xmm0 # 0x23008 xorl %r8d, %r8d testq %rcx, %rcx je 0x1454e movq (%rsi,%r8,8), %r9 movq (%rdx,%r8,8), %r10 movq (%rdi,%r8,8), %r11 xorpd %xmm1, %xmm1 xorl %ebx, %ebx movl (%r9,%rbx,4), %r14d xorps %xmm2, %x...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
gauden_norm_wt_var
void gauden_norm_wt_var(vector_t ***in_var, vector_t ***wt_var, int32 pass2var, float32 ***dnom, vector_t ***mean, uint32 n_mgau, uint32 n_feat, uint32 n_density, const uint32 *veclen, int32 tiedvar) { uint32 i, j, k, l; if (tiedvar) { gauden_tie_vars_dnoms(wt_var,...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, 0x8(%rsp) movl %edx, %ebp movq %rsi, %r15 movq %rdi, 0x18(%rsp) cmpl $0x0, 0x78(%rsp) movl %r9d, %eax movq %rax, 0x10(%rsp) je 0x14b2a cmpl $0x0, 0x60(%rsp) je 0x14948 xorl %eax, %eax testl %ebp, %ebp jne 0x148a2 movq 0x70(%rs...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
gauden_smooth_var
int gauden_smooth_var(vector_t ***var, float32 **var_floor, uint32 n_mgau, uint32 n_stream, uint32 n_density, const uint32 *veclen) { uint32 i, j, k, l; float32 flr; for (j = 0; j < n_stream; j++) { for (l = 0; l < veclen[j]; l++) { flr = var_floor[j][l]; for (i = 0; i ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rsi, -0x8(%rsp) testl %ecx, %ecx je 0x1586e movl %ecx, %esi movl %edx, %ecx movl %r8d, %r10d xorl %r11d, %r11d movl (%r9,%r11,4), %ebx testq %rbx, %rbx je 0x15866 movq -0x8(%rsp), %rax movq (%rax,%r11,8), %r14 xorl %r15d, %r15d testl %edx, %edx je ...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
solve_quadratic
uint32 solve_quadratic(float64 x, float64 y, float64 z, float64 *root1, float64 *root2) { float64 temp; if (x == 0) { if (y != 0) { (*root1) = (*root2) = -z/y; return TRUE; } else return FALSE; } temp = y * y - (4 * x * z); if (temp < 0) { if (y != 0 && fabs(temp/(y*y)) ...
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx movq %rdi, %r14 xorpd %xmm3, %xmm3 ucomisd %xmm3, %xmm0 jne 0x15934 jp 0x15934 ucomisd %xmm3, %xmm1 jne 0x1591a jnp 0x1599d xorpd 0x1032e(%rip), %xmm2 # 0x25c50 divsd %xmm1, %xmm2 movsd %xmm2, (%rbx) movsd %xmm2, (%r14) jmp 0x159f7 movapd %xmm0, %xmm4 movsd 0x10...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
gauden_norm_wt_mmie_mean
void gauden_norm_wt_mmie_mean(vector_t ***in_mean, vector_t ***wt_mean, vector_t ***wt_num_mean, vector_t ***wt_den_mean, vector_t ***in_var, vector_t ***wt_num_var, vector_t ***wt_den_var, float32 ***num_dnom, float32 ***den_dnom, uint32 n_mgau, uint32 n_feat, uint32 n_densi...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movss %xmm0, 0x20(%rsp) movq %r9, 0x48(%rsp) movq %r8, 0x40(%rsp) movq %rcx, 0x30(%rsp) movq %rdx, 0x28(%rsp) movl 0xa8(%rsp), %eax testl %eax, %eax je 0x15e8b movq %rsi, %r13 movq %rdi, %rbp movq 0xc0(%rsp), %r10 movq 0xa0(%rsp), %rbx m...
/cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c
vector_normalize
int vector_normalize(vector_t v, uint32 dim) { uint32 i; float64 s; int ret_val = S3_SUCCESS; for (i = 0, s = 0; i < dim; i++) s += v[i]; if (s != 0) { for (i = 0; i < dim; i++) v[i] /= s; } else { ret_val = S3_WARNING; } return ret_val; }
xorpd %xmm1, %xmm1 movl %esi, %ecx xorpd %xmm0, %xmm0 testl %esi, %esi je 0x162c5 xorl %eax, %eax xorps %xmm2, %xmm2 cvtss2sd (%rdi,%rax,4), %xmm2 addsd %xmm2, %xmm0 incq %rax cmpq %rax, %rcx jne 0x162b1 ucomisd %xmm1, %xmm0 jne 0x162cd jnp 0x162f3 xorl %eax, %eax testl %esi, %esi je 0x162f2 xorl %edx, %edx xorps %xmm1...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/vector.c
acmod_set_set_n_tri_hint
int32 acmod_set_set_n_tri_hint(acmod_set_t *acmod_set, uint32 n_tri) { assert(acmod_set->multi == NULL); assert(acmod_set->max_n_multi == 0); assert(acmod_set->n_multi == 0); if (n_tri > 0) { acmod_set->multi = ckd_calloc(n_tri, sizeof(acmod_t)); acmod_set->max_n_multi = n_tri; ...
pushq %r14 pushq %rbx pushq %rax cmpq $0x0, 0x10(%rdi) jne 0x16523 movq %rdi, %r14 cmpl $0x0, 0x1c(%rdi) jne 0x16542 cmpl $0x0, 0x18(%r14) jne 0x16561 movl %esi, %ebx testl %esi, %esi je 0x16519 movl %ebx, %edi leaq 0x10914(%rip), %rdx # 0x26e16 movl $0x10, %esi movl $0xc1, %ecx callq 0x94c8 movq %rax, 0x10(%r14) m...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_add_ci
acmod_id_t acmod_set_add_ci(acmod_set_t *acmod_set, const char *name, const char **attrib) { uint32 id; if (acmod_set->n_multi > 0) { E_FATAL("Current acmod_set implementation requires all CI phones" "to be defined before defining multi phones\n"); } if (acmod_set->n_ci == acmod_set->max_n_ci...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax cmpl $0x0, 0x18(%rdi) jne 0x1665f movq %rdi, %rbx movl 0x8(%rdi), %eax cmpl 0xc(%rdi), %eax je 0x16674 movq %rdx, %r14 movl 0x20(%rbx), %r15d leal 0x1(%r15), %ecx movl %ecx, 0x20(%rbx) incl %eax movl %eax, 0x8(%rbx) movq %rsi, %rdi callq 0x2420 movq (%rbx), %rcx le...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_name2id
acmod_id_t acmod_set_name2id(acmod_set_t *acmod_set, const char *name) { uint32 i; char tmp_store[1024]; char *tmp; int n_scan; int n_assign; char base[1024]; acmod_id_t base_id; char left[1024]; acmod_id_t left_id; char right[1024]; acmod_id_t right_id; char *word...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1010, %rsp # imm = 0x1010 movq %rsi, %r14 movq %rdi, %rbx leaq 0xc10(%rsp), %r15 movq %r15, %rdi callq 0x2090 leaq 0xf7a8(%rip), %rsi # 0x2602d leaq 0x10(%rsp), %rdx movq %rsp, %rcx movq %r15, %rdi xorl %eax, %eax callq 0x22f0 cmpl $0x1, %eax...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_id2s2name
const char * acmod_set_id2s2name(acmod_set_t *acmod_set, acmod_id_t id) { static char str[1024]; char *pmap = WORD_POSN_CHAR_MAP; acmod_id_t base; acmod_id_t left; acmod_id_t right; word_posn_t posn; if (id < acmod_set->n_ci) return acmod_set->ci[id].name; else if (id < ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %esi, %r9d movq %rdi, %r14 cmpl %esi, 0x8(%rdi) jbe 0x16ab5 movq (%r14), %rax movl %r9d, %ecx leaq (%rcx,%rcx,2), %rcx movq (%rax,%rcx,8), %r14 jmp 0x16b4f xorl %ebx, %ebx cmpl %r9d, 0x20(%r14) jbe 0x16b4c leaq 0x14(%rsp), %r15 leaq...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_id2name
const char * acmod_set_id2name(acmod_set_t *acmod_set, acmod_id_t id) { static char str[1024]; char *pmap = WORD_POSN_CHAR_MAP; acmod_id_t base; acmod_id_t left; acmod_id_t right; word_posn_t posn; if (id < acmod_set->n_ci) return acmod_set->ci[id].name; else if (id < acmod_set->n...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movl %esi, %r9d movq %rdi, %rbx cmpl %esi, 0x8(%rdi) jbe 0x16c30 movq (%rbx), %rax movl %r9d, %ecx leaq (%rcx,%rcx,2), %rcx movq (%rax,%rcx,8), %rbx jmp 0x16cbd cmpl %r9d, 0x20(%rbx) jbe 0x16cbb leaq 0xc(%rsp), %r14 leaq 0x8(%rsp), %r15 leaq 0x4(%r...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_base_phone
acmod_id_t acmod_set_base_phone(acmod_set_t *acmod_set, acmod_id_t id) { uint32 addr; if (id < acmod_set->n_ci) return id; else if (id < acmod_set->next_id) { addr = id - acmod_set->n_ci; return acmod_set->multi[addr].base; } else { E_ERROR("acmod_set_base_phone() ID==%u is out-of-range\n", id...
movl %esi, %eax movl %esi, %ecx subl 0x8(%rdi), %ecx jb 0x16e25 cmpl %eax, 0x20(%rdi) jbe 0x16df9 movq 0x10(%rdi), %rax shlq $0x4, %rcx movzbl (%rax,%rcx), %eax retq pushq %rax leaq 0x10015(%rip), %rsi # 0x26e16 leaq 0x10510(%rip), %rcx # 0x27318 movl $0x31c, %edx # imm = 0x31C movl $0x4, %edi movl %...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
acmod_set_attrib
const char ** acmod_set_attrib(acmod_set_t *acmod_set, acmod_id_t id) { char **attrib_list; uint32 addr; if (id < acmod_set->n_ci) { attrib_list = acmod_set->ci[id].attrib; } else if (id < acmod_set->next_id) { addr = id - acmod_set->n_ci; attrib_list = acmod_set->multi[addr].attrib; } ...
pushq %rbx movl %esi, %r8d movl %esi, %eax subl 0x8(%rdi), %eax jae 0x16f1a movq (%rdi), %rax movl %r8d, %ecx leaq (%rcx,%rcx,2), %rcx leaq (%rax,%rcx,8), %rax addq $0x8, %rax jmp 0x16f2f cmpl %r8d, 0x20(%rdi) jbe 0x16f56 movq 0x10(%rdi), %rcx shlq $0x4, %rax addq %rcx, %rax addq $0x8, %rax movq (%rax), %rbx testq %rbx...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c
reindex
uint32 reindex(dtree_node_t *node, uint32 *next_id) { node->node_id = (*next_id)++; if (!IS_LEAF(node)) { return reindex(node->y, next_id) + reindex(node->n, next_id) + 1; } else { return 1; } }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 xorl %ebx, %ebx movl (%r14), %eax leal 0x1(%rax), %ecx movl %ecx, (%r14) movl %eax, (%r15) movq 0x58(%r15), %rdi testq %rdi, %rdi jne 0x170e5 cmpq $0x0, 0x60(%r15) je 0x170f7 movq %r14, %rsi callq 0x170bc movq 0x60(%r15), %r15 addl %eax, %ebx incl %ebx jm...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
prune_subtrees
uint32 prune_subtrees(dtree_node_t *node) { uint32 n_pruned; if (!IS_LEAF(node)) { n_pruned = cnt_node(node->y) + cnt_node(node->n); prune_subtrees(node->y); node->y = NULL; prune_subtrees(node->n); node->n = NULL; return n_pruned; } else { /* it is a leaf node; nothing to do */ return 0; ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x58(%rdi), %r14 testq %r14, %r14 jne 0x171bf cmpq $0x0, 0x60(%rbx) je 0x17201 movq %r14, %rdi callq 0x17088 movl %eax, %r15d movq 0x60(%rbx), %rdi callq 0x17088 movl %eax, %ebp addl %r15d, %ebp movq %r14, %rdi callq 0x171a5 xorl %r14d, %r14d m...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
print_final_tree_recur
static void print_final_tree_recur(FILE *fp, dtree_node_t *node, pset_t *pset) { if (!IS_LEAF(node)) { fprintf(fp, "%u %u %u %e %e ", node->node_id, node->y->node_id, node->n->node_id, node->wt_ent_dec, node->occ); print_comp_quest(fp, pset, (comp_quest_t *)node->q); fprintf(fp, "\n"); prin...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx leaq 0x10350(%rip), %r12 # 0x27600 movq 0x58(%r14), %rax testq %rax, %rax jne 0x172c0 cmpq $0x0, 0x60(%r14) je 0x17319 movl (%r14), %edx movl (%rax), %ecx movq 0x60(%r14), %rax movl (%rax), %r8d movsd 0x48(%r14), ...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
read_final_tree
dtree_t * read_final_tree(FILE *fp, pset_t *pset, uint32 n_pset) { dtree_t *out; dtree_node_t *node; uint32 n_node; char *s, str[128]; lineiter_t *ln = NULL; uint32 n_scan; uint32 i, node_id, node_id_y, node_id_n; comp_quest_t *q; float64 ent; float32 occ; int err; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movl %edx, 0x1c(%rsp) movq %rsi, 0x28(%rsp) movq %rdi, %rbx leaq 0xfe6c(%rip), %rdx # 0x2741e movl $0x1, %edi movl $0x10, %esi movl $0x111, %ecx # imm = 0x111 callq 0x94c8 movq %rax, %r13 movq %rbx, %rdi callq 0xcd29 movq...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
free_tree
void free_tree(dtree_t *tr) { uint32 i; dtree_node_t *node; for (i = 0; i < tr->n_node; i++) { node = &tr->node[i]; if (node->mixw_occ) ckd_free_3d((void ***)node->mixw_occ); if (node->means) ckd_free_3d((void ***)node->means); if (node->vars) ckd_free_3d((void ***)node->vars); if (nod...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx cmpl $0x0, 0x8(%rdi) je 0x1791d movl $0x28, %r14d xorl %r15d, %r15d movq (%rbx), %r12 movq -0x10(%r12,%r14), %rdi testq %rdi, %rdi je 0x178e2 callq 0x9709 movq -0x8(%r12,%r14), %rdi testq %rdi, %rdi je 0x178f1 callq 0x9709 movq (%r12,%r14), %rdi tes...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
mk_disj
void mk_disj(dtree_node_t *node, uint32 clust, comp_quest_t *q, quest_t *conj, uint32 c_idx, uint32 *d_idx) { if (IS_LEAF(node)) { if (node->clust == clust) { uint32 i; uint32 d; d = *d_idx; q->prod_len[d] = c_idx; q->conj_q[d] = (quest_t *)ckd_calloc(c_idx, sizeof(quest_t)); fo...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r9, (%rsp) movl %r8d, %ebp movq %rcx, %r14 movq %rdx, %r15 movl %esi, %r12d movq %rdi, %r13 movq 0x58(%r13), %rdi testq %rdi, %rdi jne 0x17966 cmpq $0x0, 0x60(%r13) je 0x179c5 movq 0x40(%r13), %rax movl (%rax), %ecx movl %ebp, %ebx shlq ...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
cnt_class
uint32 cnt_class(dtree_node_t *node, uint32 *n_a, uint32 *n_b) { if (IS_LEAF(node)) { if (node->clust) ++(*n_a); else ++(*n_b); } else { cnt_class(node->y, n_a, n_b); cnt_class(node->n, n_a, n_b); } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 xorl %r13d, %r13d xorl %r12d, %r12d movq 0x58(%r15), %rdi testq %rdi, %rdi jne 0x17a6a cmpq $0x0, 0x60(%r15) je 0x17a86 movq %r14, %rsi movq %rbx, %rdx callq 0x17a40 movq 0x60(%r15), %r15 testb $...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
prune_leaves
uint32 prune_leaves(dtree_node_t *node, pset_t *pset) { dtree_node_t *y, *n; uint32 y_clust, n_clust; if (IS_LEAF(node)) return NO_CLUST; y = node->y; n = node->n; if (!IS_LEAF(y)) { y_clust = prune_leaves(y, pset); } else { y_clust = y->clust; } if (!IS_LEAF(n))...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movq 0x58(%rdi), %rdi testq %rdi, %rdi jne 0x17ac9 cmpq $0x0, 0x60(%rbx) je 0x17b1f movq 0x60(%rbx), %r15 cmpq $0x0, 0x58(%rdi) jne 0x17adb cmpq $0x0, 0x60(%rdi) je 0x17b2f movq %r14, %rsi callq 0x17aac movl %eax, %ebp cmpq $0x0, 0x5...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
leaf_mixw_occ
uint32 leaf_mixw_occ(dtree_node_t *node, pset_t *pset, float32 ****mixw_occ, uint32 *node_id, uint32 n_state, uint32 n_stream, uint32 n_density, uint32 off) { uint32 i, j, k; if (IS_LEAF(node)) { node_id[off] = node->node_id; for (i = 0; i < n_state; i++) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, 0x4(%rsp) movl %r8d, %ebp movq %rcx, %r12 movq %rdx, %r14 movq %rsi, %r13 movq %rdi, %r15 movl 0x48(%rsp), %eax movl 0x40(%rsp), %ebx movq 0x58(%r15), %rdi testq %rdi, %rdi jne 0x17b71 cmpq $0x0, 0x60(%r15) je 0x17b93 movq %r13, %rs...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
leaf_mean_vars
uint32 leaf_mean_vars(dtree_node_t *node, pset_t *pset, float32 ****means, float32 ****vars, uint32 *node_id, uint32 n_state, uint32 n_stream, uint32 *veclen, uint32 off) { uint32 i, j, k; if (IS_LEAF(node)) { node_id[off] = node->node_id; for ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, (%rsp) movq %r8, %r12 movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r13 movq %rdi, %r15 movl 0x50(%rsp), %eax movq 0x48(%rsp), %rbp movq 0x58(%r15), %rdi testq %rdi, %rdi jne 0x17c40 cmpq $0x0, 0x60(%r15) je 0x17c6b subq $0x8, %rsp mo...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
tied_state
uint32 tied_state(dtree_node_t *node, acmod_id_t b, acmod_id_t l, acmod_id_t r, word_posn_t wp, pset_t *pset) { uint32 dfeat[4]; dfeat[0] = (uint32)l; dfeat[1] = (uint32)b; dfeat[2] = (uint32)r; dfeat[3] = (uint32)wp; if (IS_LEAF(node)) { /* Got to a state cluster. Return...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r9, %rbx movl %r8d, %ebp movl %ecx, %r14d movl %edx, %r15d movl %esi, %r12d movq %rdi, %r13 movl %edx, (%rsp) movl %esi, 0x4(%rsp) movl %ecx, 0x8(%rsp) movl %r8d, 0xc(%rsp) cmpq $0x0, 0x58(%rdi) jne 0x17dcb cmpq $0x0, 0x60(%r13) je...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
cnt_twig
uint32 cnt_twig(dtree_node_t *node) { if (IS_LEAF(node)) { return 0; } else if (IS_LEAF(node->y) && IS_LEAF(node->n)) { return 1; } else { if (IS_LEAF(node->y) && !IS_LEAF(node->n)) { return cnt_twig(node->n); } else if (!IS_LEAF(node->y) && IS_LEAF(node->n)) { return cnt_twig(node->y); ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rcx xorl %ebx, %ebx movq %rcx, %r14 movq 0x58(%rcx), %rdi testq %rdi, %rdi jne 0x17e2f cmpq $0x0, 0x60(%r14) je 0x17ea3 movq 0x58(%rdi), %rax testq %rax, %rax jne 0x17e69 cmpq $0x0, 0x60(%rdi) jne 0x17e51 movq 0x60(%r14), %rcx cmpq $0x0, 0x58(%rcx) jne 0x17e51 cmpq $0x0, 0x6...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
best_leaf_node
dtree_node_t * best_leaf_node(dtree_node_t *node) { dtree_node_t *cmp_y, *cmp_n, *ret; ret = NULL; if (IS_LEAF(node)) { ret = node; } else { cmp_y = best_leaf_node(node->y); cmp_n = best_leaf_node(node->n); if ((cmp_y == NULL || cmp_y->q == NULL) && (cmp_n == NULL || cmp_n->q == NULL)) {...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x58(%rdi), %rdi testq %rdi, %rdi jne 0x1935d cmpq $0x0, 0x60(%r14) je 0x193c5 callq 0x19346 movq %rax, %rbx movq 0x60(%r14), %rdi callq 0x19346 testq %rbx, %rbx je 0x1937a cmpq $0x0, 0x40(%rbx) jne 0x19397 testq %rax, %rax je 0x193bd movq 0x40(%rax), %rcx testq %rc...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c
s3parse_comp_quest
int s3parse_comp_quest(pset_t *pset, uint32 n_pset, comp_quest_t *q, char *in_str) { char *s; uint32 i; s = in_str; for (; *s != '\0' && isspace((unsigned char)*s); s++); if (*s == '\0') { E_ERROR("Empty string seen for composite question\n"); return S3_ERROR; } if (*s ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movb (%rcx), %bl testb %bl, %bl je 0x1f7a3 movq %rcx, %r13 movq %rdx, %r14 movl %esi, %ebp movq %rdi, %r15 callq 0x2470 movq (%rax), %rax leaq 0x1(%r13), %r12 movzbl %bl, %ecx testb $0x20, 0x1(%rax,%rcx,2) je 0x1f796 movb (%r12), %bl incq %r12...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/quest.c
best_q
float64 best_q(float32 ****mixw, float32 ****means, float32 ****vars, uint32 *veclen, uint32 n_model, uint32 n_state, uint32 n_stream, uint32 n_density, float32 *stwt, uint32 **dfeat, uint32 n_dfeat, quest_t *all_q, uint32 n_all_q, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xe8, %rsp movsd %xmm0, 0xb8(%rsp) movl %r9d, 0x10(%rsp) movq %rcx, %r12 movq %rdx, 0xa0(%rsp) movq %rsi, %r15 movq %rdi, %r14 callq 0x9a8f leaq 0x33df(%rip), %rsi # 0x233cf movq %rax, %rdi callq 0xb19f movq %rax, %r13 leaq 0x33d6(%rip), %rsi ...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/best_q.c
heapify32b
void heapify32b(float32 *a, uint32 *k, uint32 i, uint32 sz, hcmpfn32b_t cmp) { uint32 l, r, b, t_k; float32 t_a; l = LEFT(i); r = RIGHT(i); /* Determine the "best" node of i, l or r */ if ((l < sz) && cmp(a[l], a[i])) b = l; else b = i; if ((r < sz) && cmp(a[r], a[b])...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r8, 0x10(%rsp) movl %edx, %r12d movq %rsi, %r14 movq %rdi, %r15 movl %ecx, 0xc(%rsp) leal 0x1(,%r12,2), %r13d movl %r12d, %ebx cmpl %ecx, %r13d jae 0x21d65 movl %r13d, %eax movss (%r15,%rax,4), %xmm0 movss (%r15,%rbx,4), %xmm1 call...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c
heap32b_extr_top
uint32 heap32b_extr_top(float32 *out_a, uint32 *out_k, float32 *a, uint32 *k, uint32 sz, hcmpfn32b_t cmp) { if (sz < 1) { E_ERROR("Heap underflow\n"); return NO_KEY; } *out_a = a[0]; *out_k = k[0]; a[0] = a[sz-1]; k[0] = k[sz-1]; sz--; heapify32b(a, k, 0, sz, cmp); re...
pushq %rbx testl %r8d, %r8d je 0x21ef9 movl %r8d, %ebx movss (%rdx), %xmm0 movss %xmm0, (%rdi) movl (%rcx), %eax movl %eax, (%rsi) decl %ebx movss (%rdx,%rbx,4), %xmm0 movss %xmm0, (%rdx) movl (%rcx,%rbx,4), %eax movl %eax, (%rcx) movq %rdx, %rdi movq %rcx, %rsi xorl %edx, %edx movl %ebx, %ecx movq %r9, %r8 callq 0x21d...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c
heap64b_ins
uint32 heap64b_ins(float64 *a, uint32 *k, uint32 sz, float64 a_v, uint32 k_v, hcmpfn64b_t cmp) { uint32 i, p; ++sz; i = sz-1; p = PARENT(i); /* if the parent does not satisfy the ordering, * then switch with i */ while ((i > 0) && !cmp(a[p], a_v)) { a[i] = a[p]; k[i] = k[p]; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %ecx, 0xc(%rsp) movsd %xmm0, 0x10(%rsp) movq %rsi, %r14 movq %rdi, %r15 movl %edx, %r13d movl %edx, 0x8(%rsp) testl %edx, %edx je 0x220af movq %r8, %r12 movl 0x8(%rsp), %eax movl %eax, %ebx leal -0x1(%rbx), %ebp movl %ebp, %r13d shr...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c
itree_new
itree_t * itree_new(uint32 n_cell_hint) { itree_t *new; uint32 i; new = ckd_calloc(1, sizeof(itree_t)); new->cell = ckd_calloc(n_cell_hint, sizeof(cell_t)); for (i = 0; i < n_cell_hint; i++) { new->cell[i].id = NO_ID; new->cell[i].sib = NULL_INDEX; new->cell[i].child = NULL_INDEX; } new-...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl %edi, %ebx leaq 0x5bad(%rip), %r12 # 0x27cfa movl $0x1, %edi movl $0x10, %esi movq %r12, %rdx movl $0x3f, %ecx callq 0x94c8 movq %rax, %r14 movl %ebx, %r15d movl $0xc, %esi movq %r15, %rdi movq %r12, %rdx movl $0x40, %ecx callq 0x94c8 movq %rax, (%r14) te...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c
itree_add_sib
cell_index_t itree_add_sib(itree_t *t, cell_index_t end, cell_id_t id) { cell_index_t new; cell_t *cell; if (t->n_cell == t->max_n_cell) { E_FATAL("index cells exhausted (exceeded the allocated size %d)\n",t->max_n_cell); } new = itree_new_cell(t); cell = t->cell; if (new !...
pushq %rax movl 0x8(%rdi), %eax movl 0xc(%rdi), %r8d cmpl %r8d, %eax je 0x2226b jae 0x22294 leal 0x1(%rax), %ecx movl %ecx, 0x8(%rdi) movq (%rdi), %rcx testl %eax, %eax je 0x22259 movl %esi, %esi leaq (%rsi,%rsi,2), %rsi movl %eax, 0x8(%rcx,%rsi,4) leaq (%rax,%rax,2), %rsi movl %edx, (%rcx,%rsi,4) movq $-0x1, 0x4(%rcx,...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c
itree_find_tri
cell_index_t itree_find(itree_t *t, cell_index_t *end, cell_index_t start, cell_id_t id) { cell_t *cell; cell_index_t i, l = NO_ID, o; cell = t->cell; if (cell[start].id != NO_ID) { for (i = start; (i != NO_ID) && (cell[i].id != id); i = cell[i].sib) l = i; if (i != NO_ID) o ...
movq (%rdi), %rdi movl $0xffffffff, %eax # imm = 0xFFFFFFFF cmpl $-0x1, (%rdi) movl $0xffffffff, %r8d # imm = 0xFFFFFFFF je 0x223a8 xorl %r8d, %r8d movl %r8d, %r9d leaq (%r9,%r9,2), %r9 cmpl %esi, (%rdi,%r9,4) je 0x223a8 leaq (%rdi,%r9,4), %r8 movl 0x8(%r8), %r8d cmpl $-0x1, %r8d jne 0x2238d cmpl $-0x1, %r8...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c
itree_enum
cell_id_t itree_enum() { cell_index_t nxt; nxt = base->cell[posn].sib; /* get next posn (given left and right) */ if (nxt != NULL_INDEX) { /* exists, so set the posn leaf node to the next one */ posn = nxt; } else { /* no next posn (given left and right) */ /* therefore get the next right cont...
movq 0x10b15(%rip), %rax # 0x33128 movq (%rax), %rax movl 0xdfd0(%rip), %ecx # 0x305ec leaq (%rcx,%rcx,2), %rcx movl 0x8(%rax,%rcx,4), %ecx cmpl $-0x1, %ecx jne 0x22672 movl 0xdfb9(%rip), %ecx # 0x305e8 leaq (%rcx,%rcx,2), %rcx movl 0x8(%rax,%rcx,4), %ecx cmpl $-0x1, %ecx jne 0x22662 movl 0xdfa2(%rip), %e...
/cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c
HttpTestListener::HttpTestListener(int)
HttpTestListener::HttpTestListener(int port) { response_status_code_ = 200; is_request_complete_ = false; is_last_value_ = false; this->local_port_ = port; this->parser_ = (http_parser*)calloc(1, sizeof(http_parser)); }
pushq %rbx movq %rdi, %rbx leaq 0x30(%rdi), %rax movq %rax, 0x20(%rdi) xorl %eax, %eax movq %rax, 0x28(%rdi) movb %al, 0x30(%rdi) leaq 0x50(%rdi), %rcx movq %rcx, 0x40(%rdi) movq %rax, 0x48(%rdi) movb %al, 0x50(%rdi) leaq 0x70(%rdi), %rcx movq %rcx, 0x60(%rdi) movq %rax, 0x68(%rdi) movb %al, 0x70(%rdi) leaq 0x90(%rdi),...
/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/http_test_listener.cc
arangodb::velocypack::Builder::reportAdd()
void Builder::reportAdd() { VELOCYPACK_ASSERT(!_stack.empty()); if (_indexes.capacity() == 0) { // make an initial reservation for several items at // a time, in order to save frequent reallocations for // the first few attributes _indexes.reserve(8); } _indexes.push_back(_pos - _stack.back().st...
subq $0x28, %rsp movq %rdi, 0x20(%rsp) movq 0x20(%rsp), %rdi movq %rdi, 0x10(%rsp) addq $0x90, %rdi callq 0x10be0 cmpq $0x0, %rax jne 0xb0eb movq 0x10(%rsp), %rdi addq $0x90, %rdi movl $0x8, %esi callq 0x10c00 movq 0x10(%rsp), %rdi movq %rdi, %rax addq $0x90, %rax movq %rax, (%rsp) movq 0x20(%rdi), %rax movq %rax, 0x8(...
/arangodb[P]velocypack/src/Builder.cpp
arangodb::velocypack::Builder::add(arangodb::velocypack::ArrayIterator&&)
uint8_t* Builder::add(ArrayIterator&& sub) { if (VELOCYPACK_UNLIKELY(_stack.empty())) { throw Exception(Exception::BuilderNeedOpenArray); } ValueLength const pos = _stack.back().startPos; if (VELOCYPACK_UNLIKELY(_start[pos] != 0x06 && _start[pos] != 0x13)) { throw Exception(Exception::BuilderNeedOpenArr...
subq $0x48, %rsp movq %rdi, 0x40(%rsp) movq %rsi, 0x38(%rsp) movq 0x40(%rsp), %rdi movq %rdi, 0x18(%rsp) addq $0x70, %rdi callq 0x4000 xorb $-0x1, %al xorb $-0x1, %al testb $0x1, %al jne 0xb6db jmp 0xb70f movl $0x18, %edi callq 0x30b0 movq %rax, %rdi movq %rdi, 0x10(%rsp) movl $0x20, %esi callq 0x4510 movq 0x10(%rsp), ...
/arangodb[P]velocypack/src/Builder.cpp
arangodb::velocypack::ObjectIterator::key(bool) const
[[nodiscard]] Slice key(bool translate = true) const { if (VELOCYPACK_UNLIKELY(!valid())) { throw Exception{Exception::IndexOutOfBounds}; } if (_current != nullptr) { Slice s{_current}; return translate ? s.makeKey() : s; } return _slice.getNthKey(_position, translate); }
subq $0x38, %rsp movb %sil, %al movq %rdi, 0x28(%rsp) andb $0x1, %al movb %al, 0x27(%rsp) movq 0x28(%rsp), %rdi movq %rdi, 0x10(%rsp) callq 0x110c0 xorb $-0x1, %al xorb $-0x1, %al xorb $-0x1, %al testb $0x1, %al jne 0x10f4d jmp 0x10f81 movl $0x18, %edi callq 0x30b0 movq %rax, %rdi movq %rdi, 0x8(%rsp) movl $0xd, %esi c...
/arangodb[P]velocypack/include/velocypack/Iterator.h
arangodb::velocypack::ObjectIterator::operator*() const
[[nodiscard]] ObjectPair operator*() const { if (_current != nullptr) { Slice key{_current}; return {key.makeKey(), Slice(_current + key.byteSize())}; } // intentionally no out-of-bounds checking here, // as it will be performed by Slice::getNthOffset() Slice key{_slice.getNthKeyUntransl...
subq $0x58, %rsp movq %rdi, 0x40(%rsp) movq 0x40(%rsp), %rax movq %rax, 0x28(%rsp) cmpq $0x0, 0x8(%rax) je 0x11169 movq 0x28(%rsp), %rax movq 0x8(%rax), %rsi leaq 0x38(%rsp), %rdi callq 0x4620 leaq 0x38(%rsp), %rdi callq 0x211e0 movq %rax, %rcx movq 0x28(%rsp), %rax movq %rcx, 0x48(%rsp) leaq 0x48(%rsp), %rcx addq $0x8...
/arangodb[P]velocypack/include/velocypack/Iterator.h
arangodb::velocypack::Dumper::appendDouble(double)
void Dumper::appendDouble(double v) { char temp[24]; double a = fabs(v); if (a >= ldexpl(1.0, 53) && a < ldexpl(1.0, 64)) { // This is a special case which we want to handle separately, because // of two reasons: // (1) The function fpconv_dtoa below only guarantees to write a // decimal rep...
subq $0x78, %rsp movq %rdi, 0x70(%rsp) movsd %xmm0, 0x68(%rsp) movq 0x70(%rsp), %rax movq %rax, 0x28(%rsp) movaps 0x122d0(%rip), %xmm1 # 0x2c780 movsd 0x68(%rsp), %xmm0 pand %xmm1, %xmm0 movlpd %xmm0, 0x48(%rsp) fldl 0x48(%rsp) fstpt 0x30(%rsp) movq %rsp, %rax fld1 fstpt (%rax) movl $0x35, %edi callq 0x31b0 fldt 0x3...
/arangodb[P]velocypack/src/Dumper.cpp
arangodb::velocypack::Dumper::dumpInteger(arangodb::velocypack::Slice)
void Dumper::dumpInteger(Slice slice) { VELOCYPACK_ASSERT(slice.isInteger()); if (slice.isType(ValueType::UInt)) { uint64_t v = slice.getUIntUnchecked(); appendUInt(v); } else if (slice.isType(ValueType::Int)) { int64_t v = slice.getIntUnchecked(); appendInt(v); } else if (slice.isType(ValueT...
subq $0x38, %rsp movq %rsi, 0x30(%rsp) movq %rdi, 0x28(%rsp) movq 0x28(%rsp), %rax movq %rax, 0x8(%rsp) leaq 0x30(%rsp), %rdi movl $0xc, %esi callq 0x1d420 testb $0x1, %al jne 0x1a7dd jmp 0x1a800 leaq 0x30(%rsp), %rdi callq 0x1fcc0 movq 0x8(%rsp), %rdi movq %rax, 0x20(%rsp) movq 0x20(%rsp), %rsi callq 0x19f70 jmp 0x1a8...
/arangodb[P]velocypack/src/Dumper.cpp
arangodb::velocypack::ArrayIterator::first() const
[[nodiscard]] uint8_t const* first() const noexcept { if (VELOCYPACK_UNLIKELY(_size == 0)) { return nullptr; } auto const head = _slice.head(); VELOCYPACK_ASSERT(head != 0x01); // no empty array allowed here if (head == 0x13) { return _slice.start() + _slice.getStartOffsetFromCompact();...
subq $0x38, %rsp movq %rdi, 0x28(%rsp) movq 0x28(%rsp), %rax movq %rax, 0x18(%rsp) cmpq $0x0, 0x10(%rax) sete %al xorb $-0x1, %al xorb $-0x1, %al testb $0x1, %al jne 0x1acd5 jmp 0x1ace0 movq $0x0, 0x30(%rsp) jmp 0x1ad58 movq 0x18(%rsp), %rdi callq 0x1cab0 movb %al, 0x27(%rsp) movzbl 0x27(%rsp), %eax cmpl $0x13, %eax jn...
/arangodb[P]velocypack/include/velocypack/Iterator.h
arangodb::velocypack::HexDump::appendHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned char)
void HexDump::appendHex(std::string& result, uint8_t value) { uint8_t x = value / 16; result.push_back((x < 10 ? ('0' + x) : ('a' + x - 10))); x = value % 16; result.push_back((x < 10 ? ('0' + x) : ('a' + x - 10))); }
subq $0x38, %rsp movb %sil, %al movq %rdi, 0x30(%rsp) movb %al, 0x2f(%rsp) movzbl 0x2f(%rsp), %eax movl $0x10, %ecx cltd idivl %ecx movb %al, 0x2e(%rsp) movq 0x30(%rsp), %rax movq %rax, 0x20(%rsp) movzbl 0x2e(%rsp), %eax cmpl $0xa, %eax jge 0x1b543 movzbl 0x2e(%rsp), %eax addl $0x30, %eax movl %eax, 0x1c(%rsp) jmp 0x1b...
/arangodb[P]velocypack/src/HexDump.cpp
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 1ul>(unsigned char const*)
static inline T readIntegerFixed(uint8_t const* start) noexcept { static_assert(std::is_unsigned<T>::value, "result type must be unsigned"); static_assert(length > 0, "length must be > 0"); static_assert(length <= sizeof(T), "length must be <= sizeof(T)"); static_assert(length <= 8); if constexpr (1 == length...
movq %rdi, -0x8(%rsp) movq -0x8(%rsp), %rax movzbl (%rax), %eax retq nop
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
wyhash(void const*, unsigned long, unsigned long, unsigned long const*)
static inline uint64_t wyhash(const void* key, size_t len, uint64_t seed, const uint64_t* secret) { const uint8_t* p = (const uint8_t*)key; seed ^= *secret; uint64_t a, b; if (_likely_(len <= 16)) { if (_likely_(len >= 4)) { a = (_wyr4(p) << 32) | _wyr4(p + ((len >> 3) <<...
subq $0x88, %rsp movq %rdi, 0x80(%rsp) movq %rsi, 0x78(%rsp) movq %rdx, 0x70(%rsp) movq %rcx, 0x68(%rsp) movq 0x80(%rsp), %rax movq %rax, 0x60(%rsp) movq 0x68(%rsp), %rax movq (%rax), %rax xorq 0x70(%rsp), %rax movq %rax, 0x70(%rsp) cmpq $0x10, 0x78(%rsp) ja 0x1bc68 cmpq $0x4, 0x78(%rsp) jb 0x1bc28 movq 0x60(%rsp), %rd...
/arangodb[P]velocypack/include/velocypack/velocypack-wyhash.h
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 4ul>(unsigned char const*)
static inline T readIntegerFixed(uint8_t const* start) noexcept { static_assert(std::is_unsigned<T>::value, "result type must be unsigned"); static_assert(length > 0, "length must be > 0"); static_assert(length <= sizeof(T), "length must be <= sizeof(T)"); static_assert(length <= 8); if constexpr (1 == length...
pushq %rax movq %rdi, (%rsp) movq (%rsp), %rdi callq 0x1c5b0 popq %rcx retq
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 5ul>(unsigned char const*)
static inline T readIntegerFixed(uint8_t const* start) noexcept { static_assert(std::is_unsigned<T>::value, "result type must be unsigned"); static_assert(length > 0, "length must be > 0"); static_assert(length <= sizeof(T), "length must be <= sizeof(T)"); static_assert(length <= 8); if constexpr (1 == length...
movq %rdi, -0x8(%rsp) movq $0x0, -0x10(%rsp) movq -0x8(%rsp), %rax movl (%rax), %ecx movl %ecx, -0x10(%rsp) movb 0x4(%rax), %al movb %al, -0xc(%rsp) movq -0x10(%rsp), %rax retq nopw %cs:(%rax,%rax)
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 7ul>(unsigned char const*)
static inline T readIntegerFixed(uint8_t const* start) noexcept { static_assert(std::is_unsigned<T>::value, "result type must be unsigned"); static_assert(length > 0, "length must be > 0"); static_assert(length <= sizeof(T), "length must be <= sizeof(T)"); static_assert(length <= 8); if constexpr (1 == length...
movq %rdi, -0x8(%rsp) movq $0x0, -0x10(%rsp) movq -0x8(%rsp), %rax movl (%rax), %ecx movl %ecx, -0x10(%rsp) movw 0x4(%rax), %cx movw %cx, -0xc(%rsp) movb 0x6(%rax), %al movb %al, -0xa(%rsp) movq -0x10(%rsp), %rax retq nop
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 8u>(unsigned char const*)
static inline T readIntFixedHelper(uint8_t const* p) noexcept { // bailout if nothing to shift or target type is too small for shift // to avoid compiler warning if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) { return 0; } else { return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) | ...
pushq %rax movq %rdi, (%rsp) movq (%rsp), %rdi addq $0x1, %rdi callq 0x1c470 movq (%rsp), %rcx movzbl (%rcx), %ecx shlq $0x8, %rcx orq %rcx, %rax popq %rcx retq nopw %cs:(%rax,%rax)
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 0u>(unsigned char const*)
static inline T readIntFixedHelper(uint8_t const* p) noexcept { // bailout if nothing to shift or target type is too small for shift // to avoid compiler warning if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) { return 0; } else { return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) | ...
pushq %rax movq %rdi, (%rsp) movq (%rsp), %rdi addq $0x1, %rdi callq 0x1c570 movq (%rsp), %rcx movzbl (%rcx), %ecx shlq $0x0, %rcx orq %rcx, %rax popq %rcx retq nopw %cs:(%rax,%rax)
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 0u, 16u>(unsigned char const*)
static inline T readIntFixedHelper(uint8_t const* p) noexcept { // bailout if nothing to shift or target type is too small for shift // to avoid compiler warning if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) { return 0; } else { return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) | ...
movq %rdi, -0x8(%rsp) xorl %eax, %eax retq nopl (%rax,%rax)
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 3u, 8u>(unsigned char const*)
static inline T readIntFixedHelper(uint8_t const* p) noexcept { // bailout if nothing to shift or target type is too small for shift // to avoid compiler warning if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) { return 0; } else { return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) | ...
pushq %rax movq %rdi, (%rsp) movq (%rsp), %rdi addq $0x1, %rdi callq 0x1c610 movq (%rsp), %rcx movzbl (%rcx), %ecx shlq $0x8, %rcx orq %rcx, %rax popq %rcx retq nopw %cs:(%rax,%rax)
/arangodb[P]velocypack/include/velocypack/velocypack-common.h
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getDouble() const
double getDouble() const { if (!isDouble()) { throw Exception(Exception::InvalidValueType, "Expecting type Double"); } auto v = readIntegerFixed<uint64_t, 8>(start() + 1); double r; std::memcpy(&r, &v, sizeof(double)); return r; }
subq $0x28, %rsp movq %rdi, 0x20(%rsp) movq 0x20(%rsp), %rdi movq %rdi, 0x8(%rsp) callq 0x1d540 testb $0x1, %al jne 0x1d9c5 movl $0x18, %edi callq 0x30b0 movq %rax, %rdi movq %rdi, (%rsp) movl $0x11, %esi leaq 0xf51f(%rip), %rdx # 0x2cec8 callq 0x1af20 movq (%rsp), %rdi leaq 0x1e177(%rip), %rsi # 0x3bb30 leaq ...
/arangodb[P]velocypack/include/velocypack/SliceBase.h
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::extractPointer() const
char const* extractPointer() const { union Converter { char const* value; char binary[sizeof(char const*)]; } converter; std::memcpy(&converter.binary[0], start() + 1, sizeof(char const*)); return converter.value; }
subq $0x18, %rsp movq %rdi, 0x10(%rsp) movq 0x10(%rsp), %rdi callq 0x1caa0 movq 0x1(%rax), %rax movq %rax, 0x8(%rsp) movq 0x8(%rsp), %rax addq $0x18, %rsp retq nopw %cs:(%rax,%rax)
/arangodb[P]velocypack/include/velocypack/SliceBase.h
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::copyBinary() const
std::vector<uint8_t> copyBinary() const { if (!isBinary()) { throw Exception(Exception::InvalidValueType, "Expecting type Binary"); } uint8_t const h = head(); VELOCYPACK_ASSERT(h >= 0xc0 && h <= 0xc7); std::vector<uint8_t> out; ValueLength length = readIntegerNonEmpty<ValueLengt...
subq $0x88, %rsp movq %rdi, 0x20(%rsp) movq %rdi, %rax movq %rax, 0x28(%rsp) movq %rdi, 0x78(%rsp) movq %rsi, 0x70(%rsp) movq 0x70(%rsp), %rdi movq %rdi, 0x30(%rsp) callq 0x1d660 testb $0x1, %al jne 0x208bc movl $0x18, %edi callq 0x30b0 movq %rax, %rdi movq %rdi, 0x18(%rsp) movl $0x11, %esi leaq 0xc757(%rip), %rdx ...
/arangodb[P]velocypack/include/velocypack/SliceBase.h
bool arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::binaryEquals<arangodb::velocypack::Slice, arangodb::velocypack::Slice>(arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice> const&) const
bool binaryEquals(SliceBase<S, T> const& other) const { if (start() == other.start()) { // same underlying data, so the slices must be identical return true; } if (head() != other.head()) { return false; } ValueLength const size = byteSize(); if (size != other.byteSize()) { ...
subq $0x58, %rsp movq %rdi, 0x40(%rsp) movq %rsi, 0x38(%rsp) movq 0x40(%rsp), %rdi movq %rdi, 0x20(%rsp) callq 0x1caa0 movq %rax, 0x28(%rsp) movq 0x38(%rsp), %rdi callq 0x1caa0 movq %rax, %rcx movq 0x28(%rsp), %rax cmpq %rcx, %rax jne 0x215a3 movb $0x1, 0x4f(%rsp) jmp 0x2164a movq 0x20(%rsp), %rdi callq 0x1cab0 movzbl ...
/arangodb[P]velocypack/include/velocypack/SliceBase.h
build_fp(double)
static Fp build_fp(double d) { uint64_t bits = get_dbits(d); Fp fp; fp.frac = bits & fracmask; fp.exp = (bits & expmask) >> 52; if (fp.exp) { fp.frac += hiddenbit; fp.exp -= expbias; } else { fp.exp = -expbias + 1; } return fp; }
subq $0x28, %rsp movsd %xmm0, 0x10(%rsp) movsd 0x10(%rsp), %xmm0 callq 0x24ad0 movq %rax, 0x8(%rsp) movabsq $0xfffffffffffff, %rax # imm = 0xFFFFFFFFFFFFF andq 0x8(%rsp), %rax movq %rax, 0x18(%rsp) movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000 andq 0x8(%rsp), %rax shrq $0x34, %rax movl %eax, 0x20(%rsp) ...
/arangodb[P]velocypack/src/fpconv.cpp
normalize(Fp*)
static void normalize(Fp* fp) { while ((fp->frac & hiddenbit) == 0) { fp->frac <<= 1; fp->exp--; } int shift = 64 - 52 - 1; fp->frac <<= shift; fp->exp -= shift; }
movq %rdi, -0x8(%rsp) movq -0x8(%rsp), %rcx movabsq $0x10000000000000, %rax # imm = 0x10000000000000 andq (%rcx), %rax cmpq $0x0, %rax jne 0x252fb movq -0x8(%rsp), %rax movq (%rax), %rcx shlq %rcx movq %rcx, (%rax) movq -0x8(%rsp), %rax movl 0x8(%rax), %ecx addl $-0x1, %ecx movl %ecx, 0x8(%rax) jmp 0x252c5 movl $0xb, -...
/arangodb[P]velocypack/src/fpconv.cpp
XXH32_endian_align
XXH_FORCE_INLINE xxh_u32 XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align) { const xxh_u8* bEnd = input + len; xxh_u32 h32; #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \ (XXH_ACCEPT_NULL_INPUT_POINTER >= 1) if (input == NULL) ...
subq $0x58, %rsp movq %rdi, 0x50(%rsp) movq %rsi, 0x48(%rsp) movl %edx, 0x44(%rsp) movl %ecx, 0x40(%rsp) movq 0x50(%rsp), %rax addq 0x48(%rsp), %rax movq %rax, 0x38(%rsp) cmpq $0x10, 0x48(%rsp) jb 0x25a59 movq 0x38(%rsp), %rax addq $-0xf, %rax movq %rax, 0x28(%rsp) movl 0x44(%rsp), %eax addl $0x9e3779b1, %eax # i...
/arangodb[P]velocypack/src/xxhash.h
VELOCYPACK_XXH32_update
XXH_PUBLIC_API XXH_errorcode XXH32_update(XXH32_state_t* state, const void* input, size_t len) { if (input == NULL) #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \ (XXH_ACCEPT_NULL_INPUT_POINTER >= 1) return XXH_OK; #else return XXH_ERROR; #endif { const xx...
subq $0x78, %rsp movq %rdi, 0x68(%rsp) movq %rsi, 0x60(%rsp) movq %rdx, 0x58(%rsp) cmpq $0x0, 0x60(%rsp) jne 0x25bb8 movl $0x1, 0x74(%rsp) jmp 0x25f47 movq 0x60(%rsp), %rax movq %rax, 0x50(%rsp) movq 0x50(%rsp), %rax addq 0x58(%rsp), %rax movq %rax, 0x48(%rsp) movq 0x58(%rsp), %rax movl %eax, %ecx movq 0x68(%rsp), %rax...
/arangodb[P]velocypack/src/xxhash.h
VELOCYPACK_XXH64_digest
XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state) { xxh_u64 h64; if (state->total_len >= 32) { xxh_u64 const v1 = state->v1; xxh_u64 const v2 = state->v2; xxh_u64 const v3 = state->v3; xxh_u64 const v4 = state->v4; h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3,...
subq $0x38, %rsp movq %rdi, 0x30(%rsp) movq 0x30(%rsp), %rax cmpq $0x20, (%rax) jb 0x26ec3 movq 0x30(%rsp), %rax movq 0x8(%rax), %rax movq %rax, 0x20(%rsp) movq 0x30(%rsp), %rax movq 0x10(%rax), %rax movq %rax, 0x18(%rsp) movq 0x30(%rsp), %rax movq 0x18(%rax), %rax movq %rax, 0x10(%rsp) movq 0x30(%rsp), %rax movq 0x20(...
/arangodb[P]velocypack/src/xxhash.h
XXH64_finalize
static xxh_u64 XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len, XXH_alignment align) { #define XXH_PROCESS1_64 \ do { \ h64 ^= (*ptr++) * XXH_PRIME64_5; \ h64 = XXH_rotl64(h64, 11) * XXH_PRIME64_1;...
subq $0xf8, %rsp movq %rdi, 0xe8(%rsp) movq %rsi, 0xe0(%rsp) movq %rdx, 0xd8(%rsp) movl %ecx, 0xd4(%rsp) movq 0xd8(%rsp), %rax andl $0x1f, %eax movq %rax, 0x8(%rsp) subq $0x1f, %rax ja 0x2831a movq 0x8(%rsp), %rax leaq 0x7444(%rip), %rcx # 0x2e400 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax jmp 0x26fc7 m...
/arangodb[P]velocypack/src/xxhash.h