name string | code string | asm string | file string |
|---|---|---|---|
secp256k1_ecdsa_signature_parse_der | int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
secp256k1_scalar r, s;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(sig != NULL);
ARG_CHECK(input != NULL);
if (secp256k1_ecdsa_sig_parse(&r, &s, input, inpu... | pushq %r14
pushq %rbx
subq $0x58, %rsp
testq %rsi, %rsi
je 0x4a6f
movq %rdx, %r14
testq %rdx, %rdx
je 0x4a76
movq %rsi, %rbx
movq %r14, 0x8(%rsp)
testq %rcx, %rcx
je 0x4a29
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
cmpb $0x30, (%r14)
jne 0x4a29
addq %rcx, %r14
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ecdsa_signature_parse_compact | int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
secp256k1_scalar r, s;
int ret = 1;
int overflow = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(sig != NULL);
ARG_CHECK(input64 != NULL);
secp256k1_scalar_se... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x0, 0x4(%rsp)
testq %rsi, %rsi
je 0x4b20
movq %rdx, %r14
testq %rdx, %rdx
je 0x4b27
movq %rsi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x4b30
movl (%r15), %ebp
addq $0x20, %r14
leaq 0x8(%rsp), %rdi
movq %r1... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_scalar_set_b32 | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
int over;
r->d[0] = secp256k1_read_be64(&b32[24]);
r->d[1] = secp256k1_read_be64(&b32[16]);
r->d[2] = secp256k1_read_be64(&b32[8]);
r->d[3] = secp256k1_read_be64(&b32[0]);
over = secp256k1_scalar... | pushq %rbp
pushq %rbx
movq 0x18(%rsi), %rax
bswapq %rax
movq %rax, (%rdi)
movq 0x10(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rsi), %r8
bswapq %r8
movq %r8, 0x10(%rdi)
movq (%rsi), %rsi
bswapq %rsi
cmpq $-0x1, %rsi
sete %r9b
cmpq $-0x2, %r8
setae %r10b
cmpq $-0x1, %r8
sete %r11b
andb %r9b, %r11b
movabsq $-... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_ecdsa_signature_serialize_der | int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
secp256k1_scalar r, s;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(output != NULL);
ARG_CHECK(outputlen != NULL);
ARG_CHECK(sig != NULL);
secp256... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
testq %rsi, %rsi
je 0x4d64
movq %rdx, %r14
testq %rdx, %rdx
je 0x4d6b
testq %rcx, %rcx
je 0x4d72
movq %rsi, %rbx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
leaq 0x80(%rsp), %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movups 0x2... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ecdsa_signature_serialize_compact | int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
secp256k1_scalar r, s;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(output64 != NULL);
ARG_CHECK(sig != NULL);
secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
testq %rsi, %rsi
je 0x4dda
testq %rdx, %rdx
je 0x4de1
movq %rsi, %rbx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
leaq 0x20(%rsp), %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movups 0x20(%rdx), %xmm0
movups 0x30(%rdx), %xmm1
movq %rsp, %r14
movaps %xmm0, (%r14)
movaps %xm... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_scalar_negate | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
secp256k1_uint128 t;
SECP256K1_SCALAR_VERIFY(a);
secp256k1_u128_from_u64(&t, ~a->d[0]);
secp256k1_u128_accum_u64(&t, SECP256K1_N_0 + 1... | pushq %rbx
movq 0x8(%rsi), %rax
orq 0x10(%rsi), %rax
orq 0x18(%rsi), %rax
movq (%rsi), %rcx
movq %rcx, %r8
notq %r8
movabsq $-0x402da1732fc9bebe, %r9 # imm = 0xBFD25E8CD0364142
leaq (%r8,%r9), %r10
xorl %edx, %edx
movq %rax, %r11
orq %rcx, %r11
cmoveq %rdx, %r10
addq %r9, %r8
movq %r10, (%rdi)
movq 0x8(%rsi), %r8
notq ... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_ecdsa_verify | int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msghash32, const secp256k1_pubkey *pubkey) {
secp256k1_ge q;
secp256k1_scalar r, s;
secp256k1_scalar m;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(msghash32 != NULL);
ARG_CHECK(sig != NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
testq %rdx, %rdx
je 0x527e
movq %rsi, %r12
testq %rsi, %rsi
je 0x5288
movq %rcx, %r15
testq %rcx, %rcx
je 0x5292
movq %rdi, (%rsp)
xorl %ebx, %ebx
leaq 0xf0(%rsp), %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x4b... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ecdsa_sign | int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *signature, const unsigned char *msghash32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
secp256k1_scalar r, s;
int ret;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(secp256k1_ecmult_gen_c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x0, (%rdi)
je 0x5426
movq %r8, %rax
movq %rdx, %r8
testq %rdx, %rdx
je 0x542d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5434
movq %r9, %r10
movq %rcx, %r9
testq %rcx, %rcx
je 0x543b
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_seckey_verify | int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
secp256k1_scalar sec;
int ret;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(seckey != NULL);
ret = secp256k1_scalar_set_b32_seckey(&sec, seckey);
secp256k1_scalar_clear(&sec);
return ret;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
testq %rsi, %rsi
je 0x5bd2
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4b30
cmpl $0x0, (%r14)
movdqa (%rbx), %xmm0
por 0x10(%rbx), %xmm0
sete %al
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
movq %xmm1, %rcx
testq %r... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_tweak_add | int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak32) {
secp256k1_ge p;
int ret = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkey != NULL);
ARG_CHECK(tweak32 != NULL);
ret = secp256k1_pubkey_load(ctx, &p, pubkey);
memset(pubke... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rsi, %rsi
je 0x60ef
movq %rdx, %r14
testq %rdx, %rdx
je 0x60f6
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x463c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
testl %eax, %eax
je... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_modinv64_var | static void secp256k1_modinv64_var(secp256k1_modinv64_signed62 *x, const secp256k1_modinv64_modinfo *modinfo) {
/* Start with d=0, e=1, f=modulus, g=x, eta=-1. */
secp256k1_modinv64_signed62 d = {{0, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 e = {{1, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 f = modinfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rcx
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
xorl %eax, %eax
movq %rax, 0x20(%rcx)
leaq 0xc0(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movq $... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_modinv64_update_fg_62_var | static void secp256k1_modinv64_update_fg_62_var(int len, secp256k1_modinv64_signed62 *f, secp256k1_modinv64_signed62 *g, const secp256k1_modinv64_trans2x2 *t) {
const uint64_t M62 = UINT64_MAX >> 2;
const int64_t u = t->u, v = t->v, q = t->q, r = t->r;
int64_t fi, gi;
secp256k1_int128 cf, cg;
int i;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq (%rcx), %rbp
movq 0x8(%rcx), %r14
movq 0x10(%rcx), %r12
movq 0x18(%rcx), %r13
movq (%rsi), %rcx
movq (%rdx), %r10
movq %rcx, %rax
imulq %rbp
movq %rdx, %r11
movq %rax, %rbx
movq %r10, %rax
imulq %r14
movq %rdx, %r8
movq %rax, %r9
add... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_modinv64_normalize_62 | static void secp256k1_modinv64_normalize_62(secp256k1_modinv64_signed62 *r, int64_t sign, const secp256k1_modinv64_modinfo *modinfo) {
const int64_t M62 = (int64_t)(UINT64_MAX >> 2);
int64_t r0 = r->v[0], r1 = r->v[1], r2 = r->v[2], r3 = r->v[3], r4 = r->v[4];
volatile int64_t cond_add, cond_negate;
#ifdef... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r12
movq %r12, %rax
sarq $0x3f, %rax
movq %rax, -0x10(%rsp)
movq (%rdx), %rax
movq -0x10(%rsp), %r10
andq %rax, %r10
addq %rcx, %r10
movq 0x8(%rdx), %rcx
movq -0x10(%rsp), %r15
... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_rfc6979_hmac_sha256_generate | static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256 *rng, unsigned char *out, size_t outlen) {
/* RFC6979 3.2.h. */
static const unsigned char zero[1] = {0x00};
if (rng->retry) {
secp256k1_hmac_sha256 hmac;
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
je 0x1c8dd
leaq 0x20(%rbx), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c92f
movl $0x20, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa97e
leaq 0x1427b(%rip), %rsi # 0x30b1a
movl... | /fanquake[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_scalar_add | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
int overflow;
secp256k1_uint128 t;
SECP256K1_SCALAR_VERIFY(a);
SECP256K1_SCALAR_VERIFY(b);
secp256k1_u128_from_u64(&t, a->d[0]);
secp256k1_u128_accum_u64(&t, b->d[0]);
r->d[0] = secp... | pushq %rbp
pushq %r14
pushq %rbx
movq (%rdx), %rax
addq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %r8
adcq $0x0, %r8
setb %cl
movzbl %cl, %ecx
addq 0x8(%rdx), %r8
movq %r8, 0x8(%rdi)
adcq 0x10(%rsi), %rcx
setb %r9b
movzbl %r9b, %r9d
addq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rdi)
adcq 0x18(%rsi), %r9
setb %sil
movq 0x... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_gej_double | static SECP256K1_INLINE void secp256k1_gej_double(secp256k1_gej *r, const secp256k1_gej *a) {
/* Operations: 3 mul, 4 sqr, 8 add/half/mul_int/negate */
secp256k1_fe l, s, t;
SECP256K1_GEJ_VERIFY(a);
r->infinity = a->infinity;
/* Formula used:
* L = (3/2) * X1^2
* S = Y1^2
* T = -X1*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, 0xb8(%rsp)
movl 0x78(%rsi), %eax
movl %eax, 0x78(%rdi)
addq $0x50, %rdi
addq $0x50, %rsi
leaq 0x28(%r14), %rdx
callq 0x1a9fa
movq 0x28(%r14), %r11
movq 0x30(%r14), %rdi
movq %rdi, 0x38(%rsp)
movq 0x40(%r14), %r... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_scalar_half | static void secp256k1_scalar_half(secp256k1_scalar *r, const secp256k1_scalar *a) {
/* Writing `/` for field division and `//` for integer division, we compute
*
* a/2 = (a - (a&1))/2 + (a&1)/2
* = (a >> 1) + (a&1 ? 1/2 : 0)
* = (a >> 1) + (a&1 ? n//2+1 : 0),
*
* where... | movq (%rsi), %rax
movq 0x8(%rsi), %rcx
shldq $0x3f, %rax, %rcx
movl %eax, %edx
andl $0x1, %edx
movq %rdx, %rax
negq %rax
movabsq $-0x2016d0b997e4df5f, %r8 # imm = 0xDFE92F46681B20A1
andq %rax, %r8
leaq (%rcx,%r8), %r9
movq %r9, (%rdi)
movq 0x8(%rsi), %r9
movq 0x10(%rsi), %r10
shldq $0x3f, %r9, %r10
movabsq $0x5d576e735... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_fe_sqrt | static void secp256k1_fe_verify(const secp256k1_fe *a) {
/* Magnitude between 0 and 32. */
SECP256K1_FE_VERIFY_MAGNITUDE(a, 32);
/* Normalized is 0 or 1. */
VERIFY_CHECK((a->normalized == 0) || (a->normalized == 1));
/* If normalized, magnitude must be 0 or 1. */
if (a->normalized) SECP256K1_FE_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq (%rsi), %r11
movq 0x8(%rsi), %r9
movq %r9, 0xe8(%rsp)
movq 0x18(%rsi), %r15
leaq (%r11,%r11), %rcx
movq %rcx, 0x8(%rsp)
movq %r15, %rax
movq %r15, 0xb0(%rsp)
mulq %rcx
movq %rax, %r8
movq %rdx, %rcx
movq 0x... | /fanquake[P]bitcoin/src/secp256k1/src/field_impl.h |
secp256k1_gej_add_zinv_var | static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, const secp256k1_fe *bzinv) {
/* Operations: 9 mul, 3 sqr, 11 add/negate/normalizes_to_zero (ignoring special cases) */
secp256k1_fe az, z12, u1, u2, s1, s2, h, i, h2, h3, t;
SECP256K1_GEJ_VERIFY(a);
S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
cmpl $0x0, 0x78(%rsi)
movl 0x50(%rdx), %eax
je 0x2b85b
movl %eax, 0x78(%rdi)
movq (%rcx), %r9
movq 0x8(%rcx), %r8
movq %r8, 0x58(%rsp)
movq 0x18(%rcx), %rbp
leaq (%r9,%r9), %rsi
movq %r9, %r10
movq %rsi, 0x20(%r... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_impl_normalizes_to_zero_var | static int secp256k1_fe_impl_normalizes_to_zero_var(const secp256k1_fe *r) {
uint64_t t0, t1, t2, t3, t4;
uint64_t z0, z1;
uint64_t x;
t0 = r->n[0];
t4 = r->n[4];
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
x = t4 >> 48;
/* The first pass e... | movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movabsq $0x1000003d0, %r8 # imm = 0x1000003D0
movq 0x20(%rdi), %rsi
movq %rsi, %rax
shrq $0x30, %rax
leaq 0x1(%r8), %rdx
imulq %rax, %rdx
addq (%rdi), %rdx
movq %rdx, %r9
andq %rcx, %r9
movabsq $0xffffefffffc2f, %rax # imm = 0xFFFFEFFFFFC2F
cmpq %rax, %r9
j... | /fanquake[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_fe_impl_inv_var | static void secp256k1_fe_impl_inv_var(secp256k1_fe *r, const secp256k1_fe *x) {
secp256k1_fe tmp = *x;
secp256k1_modinv64_signed62 s;
secp256k1_fe_normalize_var(&tmp);
secp256k1_fe_to_signed62(&s, &tmp);
secp256k1_modinv64_var(&s, &secp256k1_const_modinfo_fe);
secp256k1_fe_from_signed62(r, &s);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rsp, %r14
movq %rax, 0x20(%r14)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0xe4f0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r... | /fanquake[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ellswift_prng | static void secp256k1_ellswift_prng(unsigned char* out32, const secp256k1_sha256 *hasher, uint32_t cnt) {
secp256k1_sha256 hash = *hasher;
unsigned char buf4[4];
#ifdef VERIFY
size_t blocks = hash.bytes >> 6;
#endif
buf4[0] = cnt;
buf4[1] = cnt >> 8;
buf4[2] = cnt >> 16;
buf4[3] = cnt >> 24;... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0xd, %ecx
movq %r14, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0xa97e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd399
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
qcc_gen_value_from | qcc_generator_ptr qcc_gen_value_from(struct qcc_context *ctx, size_t item_size,
size_t item_stride, const void *data,
size_t count)
{
QCC_ARENA_POD(ctx->arena, qcc_generator_value_from, res);
res->base.context = ctx;
res->base.type_si... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x18(%rdi), %rdi
movl $0x30, %esi
callq 0x330d
movq %r13, (%rax)
movq %r12, 0x8(%rax)
leaq 0x1a(%rip), %rcx # 0x3a59
movq %rcx, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x... | /skhoroshavin[P]qcc/src/generator.c |
main | int main()
{
const Topic PRINT_TOPIC = 1;
const Topic PAPER_ORIENTATION_TOPIC = 2;
const Topic APPLICATION_TOPIC = 3;
Application* application = new Application(APPLICATION_TOPIC);
Dialog* dialog = new Dialog(application, PRINT_TOPIC);
Button* button = new Button(dialog, PAPER_ORIENTATION_TOPIC... | pushq %r15
pushq %r14
pushq %rbx
movl $0x18, %edi
callq 0x20e0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x2140
movq 0x29c0(%rip), %rax # 0x4fa8
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x20e0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2110
... | /BartVandewoestyne[P]Design-Patterns-GoF/Behavioral_Patterns/Chain_of_Responsibility/chain_of_responsibility1.cpp |
operator>>(std::istream&, Circuit&) | istream &operator>>(istream &s, Circuit &C) {
unsigned int nG, te;
s >> nG >> C.nWires;
C.GateT.resize(nG);
C.GateI.resize(nG);
C.GateO.resize(nG);
s >> te;
C.numI.resize(te);
for (unsigned int i = 0; i < C.numI.size(); i++) {
s >> C.numI[i];
}
s >> te;
C.numO.resize(te);
for (unsigned in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c(%rsp), %r15
movq %r15, %rsi
callq 0x22e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x22e0
leaq 0x38(%r14), %rdi
movl (%r15), %esi
movq %rdi, 0x10(%rsp)
callq 0x5efe
leaq 0x50(%r14), %r12
movl (%r15),... | /KULeuven-COSIC[P]Limbo/BristolCircuit.cpp |
Circuit::recompute_map() | void Circuit::recompute_map() {
unsigned int nG = GateT.size();
num_AND = 0;
total_num_AND = 0;
for (unsigned int i = 0; i < nG; i++) {
if (GateT[i] == AND) {
num_AND++;
total_num_AND++;
}
if (GateT[i] == MAND) {
total_num_AND += GateO[i].size();
}
}
// Define map between... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %r15
subq %rax, %r15
sarq $0x2, %r15
movq $0x0, 0xb0(%rdi)
xorl %esi, %esi
testl %r15d, %r15d
je 0x45ac
movq 0x68(%rbx), %rcx
movl %r15d, %edx
addq $0x8, %rcx
xorl %edi, %edi
xorl %r8d, %r8d
movl (%rax,%rdi,4), %r9d
cmpl $0x5, %r9d
... | /KULeuven-COSIC[P]Limbo/BristolCircuit.cpp |
Circuit::base_circuit_shares(std::vector<std::array<unsigned long, 1ul>, std::allocator<std::array<unsigned long, 1ul>>> const&, std::vector<std::array<unsigned long, 1ul>, std::allocator<std::array<unsigned long, 1ul>>> const&, std::vector<std::array<unsigned long, 1ul>, std::allocator<std::array<unsigned long, 1ul>>>... | void Circuit::base_circuit_shares(
const std::vector<std::array<uint64_t, PARTY64>> &witness_shares_in,
const std::vector<std::array<uint64_t, PARTY64>> &output_mult_shares,
std::vector<std::array<uint64_t, PARTY64>> &witness_shares_out,
std::vector<std::array<uint64_t, PARTY64>> &right_input_mult_share... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, 0x28(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl (%rdi), %esi
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5f9e
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
je 0... | /KULeuven-COSIC[P]Limbo/BristolCircuit.cpp |
Circuit::base_circuit(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>>&) const | bool Circuit::base_circuit(const vector<uint8_t> &inputs,
vector<uint8_t> &outputs) const {
vector<uint8_t> W(nWires);
for (unsigned int i = 0; i < nWires; i++) {
W[i] = -1;
}
// Load inputs
unsigned int cnt = 0;
for (unsigned int i = 0; i < numI.size(); i++) {
for (unsig... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %esi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x602c
cmpl $0x0, (%r14)
je 0x5461
xorl %eax, %eax
movq 0x8(%rsp), %rcx
movb $-0x1, (%rcx,%rax)
incq %rax
movl (%r14), %ecx
cmpq %rcx, %rax
jb 0x544d
movq 0... | /KULeuven-COSIC[P]Limbo/BristolCircuit.cpp |
Circuit::sort(bool) | void Circuit::sort(bool test) {
vector<bool> used(nWires);
for (unsigned int i = 0; i < nWires; i++) {
used[i] = false;
}
// Define inputs
unsigned int cnt = 0;
for (unsigned int i = 0; i < numI.size(); i++) {
for (unsigned int j = 0; j < numI[i]; j++) {
used[cnt] = true;
cnt++;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rcx
callq 0x6972
movl (%rbx), %eax
testl %eax, %eax
je 0x5868
xorl %ecx, %ecx
movq 0x10(%rsp), %rdx
movl %ecx... | /KULeuven-COSIC[P]Limbo/BristolCircuit.cpp |
Keccak_HashFinal | HashReturn Keccak_HashFinal(Keccak_HashInstance *instance,
BitSequence *hashval) {
HashReturn ret = (HashReturn)KeccakWidth1600_SpongeAbsorbLastFewBits(
&instance->sponge, instance->delimitedSuffix);
if (ret == SUCCESS)
return (HashReturn)KeccakWidth1600_SpongeSqueeze(
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0xd8(%rdi), %esi
callq 0x14b1d
testl %eax, %eax
je 0x147e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0xd4(%r14), %edx
shrl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14b9a
| /KULeuven-COSIC[P]Limbo/keccak/KeccakHash.c |
asc2nibble | unsigned char asc2nibble(char c) {
if ((c >= '0') && (c <= '9'))
return c - '0';
if ((c >= 'A') && (c <= 'F'))
return c - 'A' + 10;
if ((c >= 'a') && (c <= 'f'))
return c - 'a' + 10;
return 16; /* error */
} | leal -0x30(%rdi), %eax
cmpb $0xa, %al
jb 0x3045
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0x3046
addb $-0x37, %dil
movl %edi, %eax
retq
leal -0x61(%rdi), %eax
addb $-0x57, %dil
cmpb $0x6, %al
movzbl %dil, %ecx
pushq $0x10
popq %rax
cmovbl %ecx, %eax
retq
| /HED-Inc[P]can-utils/lib.c |
Controller::HandleInput(bool&, Snake&) const | void Controller::HandleInput(bool &running, Snake &snake) const {
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
running = false;
} else if (e.type == SDL_KEYDOWN) {
switch (e.key.keysym.sym) {
case SDLK_UP:
ChangeDirection(snake, Snake::Direction::kUp,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rdi
callq 0x3190
testl %eax, %eax
je 0x6423
movl $0xbfffffb1, %ebp # imm = 0xBFFFFFB1
leaq 0x201e(%rip), %r12 # 0x83b8
leaq 0x8(%rsp), %r15
movl 0x8(%rsp), %eax
cmpl $0x300, %eax ... | /YP-Yang-hub[P]Plane-Game/src/controller.cpp |
Renderer::Renderer(unsigned long, unsigned long, unsigned long, unsigned long) | Renderer::Renderer(const std::size_t screen_width,
const std::size_t screen_height,
const std::size_t grid_width, const std::size_t grid_height)
: screen_width(screen_width),
screen_height(screen_height),
grid_width(grid_width),
grid_height(grid_height) {
//... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x38(%rdi)
movq %rdx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %r8, 0x50(%rdi)
movl $0x20, %edi
callq 0x3240
testl %eax, %eax
jns 0x64ed
movq 0x5b85(%rip), %r12 # 0xbff0
leaq 0x1f6e(%rip), %rsi # 0x8... | /YP-Yang-hub[P]Plane-Game/src/renderer.cpp |
Renderer::Render(std::vector<Obstacle, std::allocator<Obstacle>>&, std::vector<std::shared_ptr<Car>, std::allocator<std::shared_ptr<Car>>>) | void Renderer::Render( std::vector<Obstacle>& obst, std::vector<std::shared_ptr<Car>> carObjects) {
SDL_Rect block;
block.w = screen_width / grid_width;
block.h = screen_height / grid_height;
// Clear screen
SDL_SetRenderDrawColor(sdl_renderer, 0x1E, 0x1E, 0x1E, 0xFF);
SDL_RenderClear(sdl_renderer);
SDL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
xorl %edx, %edx
divq 0x48(%rdi)
movl %eax, 0x8(%rsp)
movq 0x40(%rdi), %rax
xorl %edx, %edx
divq 0x50(%rdi)
movq %rsi, %r15
movl %eax, 0xc(%rsp)
movq 0x8(%rdi), %rdi
movl $0x1e, %esi
m... | /YP-Yang-hub[P]Plane-Game/src/renderer.cpp |
Obstacle::newPos(int) | int Obstacle::newPos(int pos){
if (pos + _speed > _limit){
pos = 0;// to make its edge visible
}else if(pos + _speed < 0){
pos = _limit;
}else{
pos += _speed;
}
return pos;
} | addl 0x14(%rdi), %esi
movl 0x18(%rdi), %ecx
movl %esi, %edx
cmovsl %ecx, %edx
xorl %eax, %eax
cmpl %ecx, %esi
cmovlel %edx, %eax
retq
nop
| /YP-Yang-hub[P]Plane-Game/src/obstacle.cpp |
stumpless_get_element_count | size_t
stumpless_get_element_count( const struct stumpless_entry *entry ) {
size_t count;
VALIDATE_ARG_NOT_NULL_UNSIGNED_RETURN( entry );
lock_entry( entry );
count = entry->element_count;
unlock_entry( entry );
return count;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb8fc
movq %rdi, %r14
movq 0x230(%rdi), %rdi
callq 0x9550
movq 0x228(%r14), %rbx
movq 0x230(%r14), %rdi
callq 0x91a0
jmp 0xb90a
leaq 0x8741(%rip), %rdi # 0x14044
callq 0x9c60
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /goatshriek[P]stumpless/src/entry.c |
stumpless_get_element_index | size_t
stumpless_get_element_index( const struct stumpless_entry *entry,
const char *name ) {
size_t name_len;
size_t i;
const struct stumpless_element *element;
int cmp_result;
VALIDATE_ARG_NOT_NULL_UNSIGNED_RETURN( entry );
VALIDATE_ARG_NOT_NULL_UNSIGNED_RETURN( name );
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xb9a2
movq %rsi, %r15
testq %rsi, %rsi
je 0xb9ab
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x95f0
testb %al, %al
je 0xb9b7
movq 0x230(%rbx), %rdi
callq 0x9550
cmpq $0x0, 0x228(%rbx)
je 0xb998
xorl %r14d, %r14d
... | /goatshriek[P]stumpless/src/entry.c |
stumpless_get_entry_app_name | const char *
stumpless_get_entry_app_name( const struct stumpless_entry *entry ) {
char *app_name_copy;
VALIDATE_ARG_NOT_NULL( entry );
lock_entry( entry );
app_name_copy = alloc_mem( entry->app_name_length + 1 );
if( !app_name_copy ) {
goto cleanup_and_return;
}
memcpy( app_name_copy, entry->app_na... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba38
movq %rdi, %rbx
movq 0x230(%rdi), %rdi
callq 0x9550
movq 0x1d8(%rbx), %rdi
incq %rdi
callq 0x9120
movq %rax, %r14
testq %rax, %rax
je 0xba2a
leaq 0x1a4(%rbx), %rsi
movq 0x1d8(%rbx), %rdx
incq %rdx
movq %r14, %rdi
callq 0x9910
callq 0xa110
movq 0x230(%rbx), %rd... | /goatshriek[P]stumpless/src/entry.c |
vstumpless_load_entry | struct stumpless_entry *
vstumpless_load_entry( struct stumpless_entry *entry,
enum stumpless_facility facility,
enum stumpless_severity severity,
const char *app_name,
const char *msgid,
const char *messa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
testq %r9, %r9
je 0xc00b
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r9, %rdi
callq 0x90a0
movq %rax, %r13
testq %rax, %rax
jne 0xc017
xorl %ebx, %ebx
... | /goatshriek[P]stumpless/src/entry.c |
stumpless_set_entry_msgid | struct stumpless_entry *
stumpless_set_entry_msgid( struct stumpless_entry *entry,
const char *msgid ) {
size_t new_msgid_length;
VALIDATE_ARG_NOT_NULL( entry );
if( unlikely( msgid && !validate_msgid( msgid, &new_msgid_length ) ) ) {
return NULL;
}
lock_entry( entry );
if(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xc67c
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc68c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9c40
testb %al, %al
je 0xc688
movq 0x230(%rbx), %rdi
callq 0x9550
movq 0x8(%rsp), %r15
movq %r15, 0x218(%rbx)
leaq 0x1f0(%rbx), %rdi
movq %... | /goatshriek[P]stumpless/src/entry.c |
glfwSwapInterval | GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot set swap interval without a current OpenGL or OpenGL ES context... | pushq %rbx
leaq 0x3cc43(%rip), %rax # 0x55928
cmpl $0x0, (%rax)
je 0x18d0b
movl %edi, %ebx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a2f0(%rip), %rdi # 0x52fe8
callq 0x25abd
testq %rax, %rax
je 0x18d14
movl %ebx, %edi
popq %rbx
jmpq *0x250(%rax)
movl $0x10001, %edi # imm = 0x10001
xorl %esi,... | /anael-seghezzi[P]glfw/src/context.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glf... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3c7ea(%rip), %r14 # 0x55928
cmpl $0x0, (%r14)
je 0x1914e
movl $0x1, %ebx
jmp 0x19225
xorl %ebx, %ebx
movl $0x20980, %edx # imm = 0x20980
movq %r14, %rdi
xorl %esi, %esi
callq 0x14110
movq 0x3b122(%rip), %rax # 0x54288
movq %rax, 0x8(%r14)
movl 0x3b120(%rip), %eax... | /anael-seghezzi[P]glfw/src/init.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x34b6c(%rip), %rax # 0x55928
cmpl $0x0, 0x20560(%rax)
je 0x20e42
cmpl $0x0, 0x20584(%rax)
jne 0x20e42
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x1fec0(%rax), %rdi
movq 0x1fed0(%rax), %rsi
movq %rax, %r13
callq *0x205d8(%rax)
movq %rax, %r15
mo... | /anael-seghezzi[P]glfw/src/x11_monitor.c |
glfwPlatformGetVideoModes | GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
GLFWvidmode* result;
*count = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
int i, j;
XRRScreenResources* sr;
XRRCrtcInfo* ci;
XRROutputInfo* oi;
sr = XRRGetScr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x0, (%rsi)
leaq 0x34a8a(%rip), %r12 # 0x55928
cmpl $0x0, 0x20560(%r12)
je 0x2101d
cmpl $0x0, 0x20584(%r12)
jne 0x2101d
movq 0x1fec0(%r12), %rdi
movq 0x1fed0(%r12), %rsi
callq *0x205d8(%r12)
movq... | /anael-seghezzi[P]glfw/src/x11_monitor.c |
updateNormalHints | static void updateNormalHints(_GLFWwindow* window, int width, int height)
{
XSizeHints* hints = XAllocSizeHints();
if (!window->monitor)
{
if (window->resizable)
{
if (window->minwidth != GLFW_DONT_CARE &&
window->minheight != GLFW_DONT_CARE)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
callq 0x14950
movq %rax, %rbx
cmpq $0x0, 0x40(%r14)
jne 0x22a9c
cmpl $0x0, 0x8(%r14)
je 0x22a72
movl 0x50(%r14), %eax
cmpl $-0x1, %eax
je 0x22a29
movl 0x54(%r14), %ecx
cmpl $-0x1, %ecx
je 0x22a29
orb $0x10, (%rbx)
mo... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwGetOSMesaColorBuffer | GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
int* height, int* format, void** buffer)
{
void* mesaBuffer;
GLint mesaWidth, mesaHeight, mesaFormat;
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x28177
leaq 0x2d852(%rip), %rax # 0x55928
cmpl $0x0, (%rax)
je 0x28146
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2a0(%rdi), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0x10(%rsp... | /anael-seghezzi[P]glfw/src/osmesa_context.c |
get_quests | int32 get_quests(node *root,int32 **qarr,int32 *nph,int32 nquests,int32 depth)
{
int32 *sortedidx,i;
if (root->nphones < 2 && depth > 3) return nquests;
if (depth > 0){
sortedidx = (int32 *)ckd_calloc(root->nphones,sizeof(int32));
for (i=0;i<root->nphones;i++) sortedidx[i] = root->phoneids... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movslq (%r13), %rdi
cmpq $0x2, %rdi
setl %al
cmpl $0x4, %r14d
setge %cl
testb %al, %cl
jne 0x4a0e
testl %r14d, %r14d
jle 0x49da
movl $0x4, %esi
leaq 0x196a7(%rip)... | /cmusphinx[P]sphinxtrain/src/programs/make_quests/main.c |
s3mixw_read | int
s3mixw_read(const char *fn,
float32 ****out_mixw,
uint32 *out_n_mixw,
uint32 *out_n_feat,
uint32 *out_n_density)
{
uint32 rd_chksum = 0;
uint32 sv_chksum;
uint32 swap;
uint32 ignore;
char *ver;
char *do_chk;
FILE *fp;
fp = s3open(fn, "rb", &swap);
if (fp == N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x4(%rsp)
leaq 0x1559a(%rip), %rsi # 0x1e9f0
movq %rsp, %rdx
callq 0x9ba7
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rax, %ra... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3mixw_io.c |
s3mixw_intv_read | int
s3mixw_intv_read(const char *fn,
uint32 mixw_s,
uint32 mixw_e,
float32 ****out_mixw,
uint32 *out_n_mixw,
uint32 *out_n_feat,
uint32 *out_n_density)
{
uint32 ignore;
char *ver;
char *do_chk;
FILE *fp;
uint32 swap;
fp = s3open(fn, "rb", &swap);
if (fp == NULL)
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %rbp
movq %rcx, %rbx
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %r15
leaq 0x153bf(%rip), %rsi # 0x1e9f0
leaq 0x14(%rsp), %rdx
callq 0x9ba7
movq %rax, %r12
movl $0xffffffff, %eax # imm = 0xFFFFFF... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3mixw_io.c |
s3mixw_write | int
s3mixw_write(const char *fn,
float32 ***mixw,
uint32 n_mixw,
uint32 n_feat,
uint32 n_density)
{
FILE *fp;
uint32 chksum = 0;
uint32 ignore = 0;
uint32 i, j, k;
s3clr_fattr();
s3add_fattr("version", MIXW_FILE_VERSION, TRUE);
s3add_fattr("chksum0", "yes", TRUE);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0x20(%rsp)
movl %eax, 0x24(%rsp)
callq 0x9984
leaq 0x15236(%rip), %rdi # 0x1e9f3
leaq 0x15237(%rip), %rsi # 0x... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3mixw_io.c |
s3clr_fattr | void s3clr_fattr()
{
int i;
for (i = 0; attrib[i]; i++) {
if (alloc[i]) {
if (attrib[i]) {
free(attrib[i]);
}
if (value[i]) {
free(value[i]);
}
alloc[i] = FALSE;
}
}
assert(i == n_attrib);
n_attrib = 0;
attrib[0] = value[0] = NULL;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x1ff7d(%rip), %rdi # 0x29910
testq %rdi, %rdi
je 0x99e5
leaq 0x20381(%rip), %r14 # 0x29d20
leaq 0x2057a(%rip), %r15 # 0x29f20
xorl %ebx, %ebx
leaq 0x1ff61(%rip), %r12 # 0x29910
cmpl $0x0, (%r14)
je 0x99ce
callq 0x2040
movq (%r15), %rdi
testq %... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
s3get_gvn_fattr | char *
s3get_gvn_fattr(char *a)
{
int i;
for (i = 0; attrib[i] && strcmp(attrib[i], a) != 0; i++);
/* value for sentinel is null as well */
assert((attrib[i] != NULL) || (value[i] == NULL));
return value[i];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1fecb(%rip), %rdi # 0x29910
testq %rdi, %rdi
sete %bpl
je 0x9a88
movq %rbx, %rsi
callq 0x2260
testl %eax, %eax
je 0x9a8d
movl $0x1, %r14d
leaq 0x1fea9(%rip), %r15 # 0x29910
movq (%r15,%r14,8), %rdi
testq %rdi, %rdi
sete %bpl
je 0x9a95... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
s3add_fattr | void
s3add_fattr(char *a,
char *v,
int dup)
{
if (n_attrib == MAX_ATTRIB) {
E_FATAL("Too many file attributes, increase MAX_ATTRIB\n");
}
if (dup) {
attrib[n_attrib] = strdup(a);
value[n_attrib] = strdup(v);
}
else {
attrib[n_attrib] = a;
value[n_attrib] = v;
}
alloc[n_attri... | pushq %r15
pushq %r14
pushq %rbx
movslq 0x2082f(%rip), %r15 # 0x2a328
cmpq $0x80, %r15
je 0x9b6c
movl %edx, %ebx
movq %rsi, %r14
testl %edx, %edx
je 0x9b28
callq 0x2410
leaq 0x1fdf9(%rip), %rcx # 0x29910
movq %rax, (%rcx,%r15,8)
movq %r14, %rdi
callq 0x2410
movq %rax, %r14
jmp 0x9b33
leaq 0x1fde1(%rip), %rax ... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
s3open | FILE *
s3open(const char *file_name,
const char *mode,
uint32 *swap)
{
FILE *fp = NULL;
if (mode[0] == 'r' && mode[1] == 'b') {
/* Read a binary file */
fp = fopen(file_name, mode);
if (fp == NULL) {
E_ERROR_SYSTEM("Unable to open %s for reading",
file_name);
return NULL;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2128, %rsp # imm = 0x2128
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0x61, %eax
je 0x9c74
cmpl $0x77, %eax
je 0x9c57
cmpl $0x72, %eax
jne 0x9ca5
cmpb $0x62, 0x1(%rsi)
jne 0x9c4d
movq %rdx, %r15
movq %r14, %rdi
callq 0x2350
testq %rax, %r... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
wr_bin_hdr | static int
wr_bin_hdr(FILE *fp)
{
uint32 i;
long padding;
int ret;
if (fprintf(fp, "s3\n") != 3) {
E_ERROR_SYSTEM("Error while writing SPHINX-III ID\n");
goto error_loc;
}
for (i = 0; attrib[i]; i++) {
ret = fprintf(fp, "%s %s\n", attrib[i], value[i]);
if (ret != (strlen(attrib[i]) +
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15ce1(%rip), %rsi # 0x1fb44
xorl %eax, %eax
callq 0x2270
cmpl $0x3, %eax
jne 0x9f3c
movq 0x1fa96(%rip), %rdx # 0x29910
testq %rdx, %rdx
je 0x9eeb
leaq 0x1fa8a(%rip), %r15 # 0x29910
movl $0x1, %ebp
leaq 0x2008... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
bio_fread_intv_3d | int
bio_fread_intv_3d(void ****arr,
size_t e_sz,
uint32 s,
uint32 e,
uint32 *d1,
uint32 *d2,
uint32 *d3,
FILE *fp,
uint32 swap,
uint32 *chksum)
{
uint32 l_d1;
uint32 l_d2;
uint32 l_d3;
uint32 s_d1;
uint32 n;
void *raw;
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x30(%rsp)
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r13
movq 0x88(%rsp), %r9
movl 0x80(%rsp), %r8d
movq 0x78(%rsp), %r12
leaq 0x1c(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
c... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
get_length | int get_length(char *file,
int *byterev)
{
FILE *fp;
int length;
int n;
struct stat statbuf;
*byterev = 0;
if (stat(file, &statbuf) < 0) {
printf("stat_retry(%s) failed\n", file);
return -1;
}
if ((fp = fopen(file, "rb")) == NULL) {
pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rsi)
leaq 0x8(%rsp), %rsi
callq 0x2290
testl %eax, %eax
js 0xa34b
leaq 0x1471e(%rip), %rsi # 0x1e9f0
movq %r15, %rdi
callq 0x2350
testq %rax, %rax
je 0xa354
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
movl $0x4, %esi
... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadfloat | int
areadfloat (char *file,
float **data_ref,
int *length_ref)
{
FILE *fp;
int length;
int ret, byterev;
int offset;
float *data;
int dummy_length;
/* Get the file length and whether the file needs to be byte-reversed */
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r15
leaq 0x4(%rsp), %rsi
callq 0xa2a0
testl %eax, %eax
js 0xa4bb
movl %eax, %ebx
leaq 0x14606(%rip), %rsi # 0x1e9f0
movq %r15, %rdi
callq 0x2350
testq %rax, %rax
je 0xa4a0
movq %rax, %r12
l... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadfloat_part | int
areadfloat_part (char *file,
int s_coeff,
int e_coeff,
float **data_ref,
int *length_ref)
{
static char p_file[MAXPATHLEN] = "";
static FILE *fp = NULL;
static int len;
static int byterev;
int r_len;
float *r_buf;
int i;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
cmpl %edx, %esi
jg 0xa776
movq %r8, %r14
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r15
leaq 0x1fdd2(%rip), %rsi # 0x2a330
callq 0x2260
testl %eax, %eax
je 0xa5eb
movq 0x20dbe(%rip), %rdi # 0x2b330
testq %r... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadint | int
areadint (char *file,
int **data_ref,
int *length_ref)
{
int fd;
int length;
int size;
int offset;
char *data;
if ((fd = open (file, O_RDONLY | O_BINARY, 0644)) < 0)
{
fprintf (stderr, "areadint: %s: can't open\n", file);
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
xorl %esi, %esi
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x2330
testl %eax, %eax
js 0xa898
movl %eax, %ebp
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
movl %eax, %edi
callq... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadshort | int
areadshort (char *file,
short **data_ref,
int *length_ref)
{
int fd;
int length;
int size;
int offset;
char *data;
if ((fd = open (file, O_RDONLY | O_BINARY, 0644)) < 0)
{
fprintf (stderr, "areadshort: %s: can't open\n", file);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorl %esi, %esi
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x2330
testl %eax, %eax
js 0xa9f7
movl %eax, %ebp
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
movl %eax, %edi
callq... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
awritefloat | int
awritefloat (char *file,
float *data,
int length)
{
int fd;
int size;
int offset;
if ((fd = open (file, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, 0644)) < 0)
{
fprintf (stderr, "awritefloat: %s: can't create\n", file);
perror("");
return -1;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, 0x4(%rsp)
movl $0x241, %esi # imm = 0x241
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x2330
testl %eax, %eax
js 0xab0f
movl %eax, %ebp
movl %ebx, %eax
... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
ckd_set_jump | jmp_buf *
ckd_set_jump(jmp_buf *env, int abort)
{
jmp_buf *old;
if (abort)
jmp_abort = 1;
old = ckd_target;
ckd_target = env;
return old;
} | testl %esi, %esi
je 0xab43
movb $0x1, 0x207fd(%rip) # 0x2b340
movq 0x207fe(%rip), %rax # 0x2b348
movq %rdi, 0x207f7(%rip) # 0x2b348
retq
| /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
_ckd_malloc__ | void *
__ckd_malloc__(size_t size, const char *caller_file, int caller_line)
{
void *mem;
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if ((mem = heap_malloc(heap_lookup(0),size)) == NULL)
if ((mem = heap_malloc(heap_lookup(1),size)) == NULL)
#else
if ((mem = malloc(size)) == NULL)
#endif
... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x22c0
testq %rax, %rax
je 0xac70
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14f68(%rip), %rdi # 0x1fbdf
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xab52
| /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
_ckd_salloc__ | char *
__ckd_salloc__(const char *orig, const char *caller_file,
int caller_line)
{
size_t len;
char *buf;
if (!orig)
return NULL;
len = strlen(orig) + 1;
buf = (char *) __ckd_malloc__(len, caller_file, caller_line);
strcpy(buf, orig);
return (buf);
} | testq %rdi, %rdi
je 0xacec
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2130
leaq 0x1(%rax), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xac53
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
xorl %eax, %eax
retq
| /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
_ckd_calloc_2d__ | void *
__ckd_calloc_2d__(size_t d1, size_t d2, size_t elemsize,
const char *caller_file, int caller_line)
{
char **ref, *mem;
size_t i, offset;
mem =
(char *) __ckd_calloc__(d1 * d2, elemsize, caller_file,
caller_line);
ref =
(char **) _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
imulq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0xac10
movq %rax, %r15
leaq (,%r14,8), %rdi
movq %r13, %rsi
movl %ebp, %edx
... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
_ckd_calloc_3d__ | void *
__ckd_calloc_3d__(size_t d1, size_t d2, size_t d3, size_t elemsize,
const char *caller_file, int caller_line)
{
char ***ref1, **ref2, *mem;
size_t i, j, offset;
mem =
(char *) __ckd_calloc__(d1 * d2 * d3, elemsize, caller_file,
caller_line);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r13
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rbp
imulq %rdi, %rbp
movq %rbp, %rdi
movq %rdx, 0x8(%rsp)
imulq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r8, 0x10(%rsp)
movl %r9d, %ec... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
hash_table_display | void
hash_table_display(hash_table_t * h, int32 showdisplay)
{
hash_entry_t *e;
int i, j;
j = 0;
printf("Hash with chaining representation of the hash table\n");
for (i = 0; i < h->size; i++) {
e = &(h->table[i]);
if (e->key != NULL) {
printf("|key:");
if (s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r12
leaq 0x12fc9(%rip), %rdi # 0x202b4
callq 0x20c0
cmpl $0x0, 0x8(%r12)
jle 0xd3c3
testl %ebx, %ebx
leaq 0x12f4c(%rip), %rax # 0x20251
leaq 0x132f7(%rip), %rcx # 0x20603
cmovneq %rcx, %rax
movq %r... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/hash_table.c |
lineiter_start | lineiter_t *
lineiter_start(FILE *fh)
{
lineiter_t *li;
li = (lineiter_t *)ckd_calloc(1, sizeof(*li));
li->buf = (char *)ckd_malloc(128);
li->buf[0] = '\0';
li->bsiz = 128;
li->len = 0;
li->fh = fh;
li = lineiter_next(li);
/* Strip the UTF-8 BOM */
if (li && 0 == strn... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x12092(%rip), %r14 # 0x20419
movl $0x1, %edi
movl $0x20, %esi
movq %r14, %rdx
movl $0x10c, %ecx # imm = 0x10C
callq 0xac10
movq %rax, %r15
movl $0x80, %edi
movq %r14, %rsi
movl $0x10d, %edx # imm = 0x10D
callq 0xac53
movq %rax, (%r15)
movb... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/pio.c |
lineiter_next | lineiter_t *
lineiter_next(lineiter_t *li)
{
if (!li->clean)
return lineiter_next_plain(li);
for (li = lineiter_next_plain(li); li; li = lineiter_next_plain(li)) {
if (li->buf) {
li->buf = string_trim(li->buf, STRING_BOTH);
if (li->buf[0] != 0 && li->buf[0] != '#')
break;
}
}
return ... | pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
sete %bpl
callq 0xe4af
movq %rax, %rbx
testq %rax, %rax
sete %al
orb %bpl, %al
jne 0xe467
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe457
movl $0x2, %esi
callq 0xd713
movq %rax, (%rbx)
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0xe457
testl %eax, %eax
jne 0xe467
movq %rb... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/pio.c |
stat_retry | int32
stat_retry(const char *file, struct stat * statbuf)
{
int32 i;
for (i = 0; i < STAT_RETRY_COUNT; i++) {
#ifndef HAVE_SYS_STAT_H
FILE *fp;
if ((fp = (FILE *)fopen(file, "r")) != 0) {
fseek(fp, 0, SEEK_END);
statbuf->st_size = ftell(fp);
fclose(fp);
return 0;
}
#else /* HAVE_SYS_STA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0xa, %ebp
leaq 0x11cd9(%rip), %r12 # 0x20419
leaq 0x11e44(%rip), %r13 # 0x2058b
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2290
testl %eax, %eax
je 0xe78a
cmpl $0xa, %ebp
jne 0xe777
mo... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/pio.c |
diff | static Bigint *
diff(Bigint *a, Bigint *b)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
#ifdef ULLong
ULLong borrow, y;
#else
ULong borrow, y;
ULong z;
#endif
i = cmp(a,b);
if (!i) {
c = Balloc(0);
if (c == NULL)
return NULL;
c->wds = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x14(%rdi), %ebp
movslq 0x14(%rsi), %rax
subl %eax, %ebp
jne 0x10903
leaq 0x1c(,%rax,4), %rax
movl -0x8(%r14,%rax), %ecx
movl -0x8(%rbx,%rax), %edx
cmpl %edx, %ecx
jne 0x108fa
addq $-0x4, %rax
cmpq $0x1c, %rax
jg 0x108df
xorl %e... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/dtoa.c |
f__cabs | float
f__cabs(float real, float imag)
#endif
{
float temp;
if (real < 0)
real = -real;
if (imag < 0)
imag = -imag;
if (imag > real) {
temp = real;
real = imag;
imag = temp;
}
if ((imag + real) == real)
return ((float) real);
temp = imag / rea... | movaps 0x31ef(%rip), %xmm3 # 0x20370
movaps %xmm0, %xmm2
xorps %xmm3, %xmm2
maxss %xmm0, %xmm2
xorps %xmm1, %xmm3
maxss %xmm1, %xmm3
movaps %xmm3, %xmm0
maxss %xmm2, %xmm0
movaps %xmm2, %xmm1
addss %xmm3, %xmm1
ucomiss %xmm0, %xmm1
jne 0x1d1a8
jp 0x1d1a8
retq
minss %xmm3, %xmm2
divss %xmm0, %xmm2
mulss %xmm2, %xmm2... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/f2c_lite.c |
astarTest_methodTesting_Test::TestBody() | TEST(astarTest, methodTesting) {
astar a;
ASSERT_EQ(a.x_start_, 0);
astar a1(0, 0, 5, 5);
ASSERT_EQ(a1.x_goal_, 5);
astar astar2(0, 0, 2, 2);
map map2;
std::vector<std::vector<int>> m1 = map2.create_map();
std::vector<std::pair<int, int>> path2;
path2 = astar2.astar_path(m1);
bool status1 = map2.... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x51a10
movq -0x280(%rbp), %rcx
movl $0x0, -0x2c(%rbp)
leaq 0x4227a(%rip), %rsi # 0x8f0fe
leaq 0x456d7(%rip), %rdx # 0x92562
leaq -0x28(%rbp), %rdi
movq %rdi, -0x278(%... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/test/test.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<bool, bool>(char const*, char const*, bool const&, bool const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x2... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/test/../vendor/googletest/googletest/include/gtest/gtest.h |
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11]() | std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
if (gtest_output_flag == NULL)
return "";
const char* const colon = strchr(gtest_output_flag, ':');
if (colon == NULL)
return internal::FilePath::ConcatPaths(
internal:... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x248(%rbp)
movq %rdi, %rax
movq %rax, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x5ca69(%rip), %rdi # 0xb2750
callq 0x4b160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x55d4b
leaq -0x11(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq ... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*) | bool UnitTestOptions::PatternMatchesString(const char *pattern,
const char *str) {
switch (*pattern) {
case '\0':
case ':': // Either ':' or '\0' marks the end of the pattern.
return *str == '\0';
case '?': // Matches any single character.
return *s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x566b1
jmp 0x56690
movl -0x1c(%rbp), %eax
subl $0x2a, %eax
je 0x566fb
jmp 0x5669a
movl -0x1c(%rbp), %eax
subl $0x3a, %eax
je 0x566b1
jmp 0x566a... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::FilterMatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
const std::string &test_name) {
const std::string& full_name = test_case_name + "." + test_name.c_str();
// Split --gtest_filter at '-', if there is one, to separate into
// positive filter and nega... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3a0a9(%rip), %rdx # 0x908d7
leaq -0x58(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x718f0
movq -0x10(%rbp), %rdi
callq 0x4b160
movq -0x110(%rbp), %rsi
movq %rax, %rdx
leaq -... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << " Expected: " << lhs_ex... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc8(%rbp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x38(%rbp), %rdi
mo... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double) | AssertionResult DoubleNearPredFormat(const char* expr1,
const char* expr2,
const char* abs_error_expr,
double val1,
double val2,
double... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd -0x28(%rbp), %xm... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x78(%rbp)
movb %sil, %al
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
mo... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
if (num_chars == -1)
num_chars = static_cast<int>(wcslen(str));
::std::stringstream stream;
for (int i = 0; i < num_chars; ++i) {
UInt32 unicode_code_point;
if (str[i] == L'\0') {
break;
} else if (i + 1 < num_chars && IsUtf... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5c589
movq -0x10(%rbp), %rdi
callq 0x4b780
movl %eax, -0x14(%rbp)
leaq -0x1a0(%rbp), %rd... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != NULL || value_param != NULL) {
printf(", where ");
if (type_param != NULL) {
printf("%s = %s", kTypeParam... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75cb0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75d00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5fc14
cmpq $0x0, -0x18(%rbp)
je 0x5fc7b
leaq 0x313d2(%rip), %rdi # 0x90fed
movb $0x0, %al
callq 0x4b0c0... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
if (failed_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
const TestCase& test_case = *unit_test.GetTestCase(i);
i... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60dd0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x60ca3
jmp 0x60dc6
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60e00
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.c_str() == NULL || output_file_.empty()) {
fprintf(stderr, "XML output file may not be null\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x761b0
movq -0x48(%rbp), %rax
leaq 0x4f898(%rip), %rcx # 0xb1350
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&'... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x57fb0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + 1) +... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x258(%rbp)
movq %rdi, %rax
movq %rax, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x63360
testb ... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::ScopedTrace::ScopedTrace(char const*, int, testing::Message const&) | GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
TraceInfo trace;
trace.file = file;
trace.line = line;
trace.message = message.GetString();
UnitTest::GetInstance()->PushGTestTrace(trace);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x76670
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x58... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::internal::RE const*, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_d... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
callq 0x71a00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x78c00
movq %rax, -0x48(%rbp)
movq -0x40(%rbp)... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::GetCurrentDir() | FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
// Windows CE doesn't have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
... | pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp # imm = 0x1080
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx # imm = 0x1001
callq 0x4b370
leaq -0x1010(%rbp), %rdi
movl $0x1001, %esi # imm = ... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveTrailingPathSeparator() const | FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory()
? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56530
movb $0x0, -0x31(%rbp)
testb $0x1, %al
jne 0x6e362
jmp 0x6e39b
movq -0x50(%rbp), %rdi
callq 0x4b680
movq -0x5... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateFolder() const | bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, NULL) ? 0 : -1;
delete [] unicode;
#elif GTEST_OS_WINDOWS
int result = _mkdir(pathname_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4b160
movq %rax, %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x4b310
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x6e54f
movq -0x20(%rbp), %rdi
callq 0x6e430
andb $0x1, %al
movb %al,... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-filepath.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79850
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4b480
addq $0xa, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp)... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-port.cc |
testing::internal::TempDir[abi:cxx11]() | std::string TempDir() {
#if GTEST_OS_WINDOWS_MOBILE
return "\\temp\\";
#elif GTEST_OS_WINDOWS
const char* temp_dir = posix::GetEnv("TEMP");
if (temp_dir == NULL || temp_dir[0] == '\0')
return "\\temp\\";
else if (temp_dir[strlen(temp_dir) - 1] == '\\')
return temp_dir;
else
return std::string(temp... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4baa0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x22e1a(%rip), %rsi # 0x91cad
callq 0x4b920
jmp 0x6ee9a
leaq -0x9(%rbp), %rdi
... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-port.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x702c9
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x4b2b0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x2d9(%rbp)
jne 0x702f7
callq 0x4bb00... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::Message& testing::Message::operator<<<char [13]>(char const (&) [13]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::Mutex::Mutex() | Mutex() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
has_owner_ = false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x4b440
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x73fdc
leaq 0x1dedf(%rip), %rdx # 0x91e40
leaq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x3, %esi
movl $0... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [31]>(char const (&) [31]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
callq 0x71a00
movq %rax, %rdi
callq 0x883e0
testb $0x1, %al
jne 0x74d61
jmp 0x74ee0
movq -0x18... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.