name string | code string | asm string | file string |
|---|---|---|---|
fpdf | double fpdf(double x, int num,int den) {
double oup,k1,k2,y,z;
if (num <= 0 || den <= 0) {
printf("Degrees Of Freedom should be real integers");
exit(1);
}
if (x < 0.) {
printf("The range of distribution only takes non-negative and real values");
exit(1);
}
k1 = (double) num;
k2 = (double) den;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testl %edi, %edi
jle 0x4715b
testl %esi, %esi
jle 0x4715b
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x47164
cvtsi2sd %edi, %xmm2
cvtsi2sd %esi, %xmm4
mulsd %xmm2, %xmm0
ucomisd %xmm4, %xmm0
jbe 0x47102
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm4, %xmm0
movapd %xmm4, %... | /rafat[P]ctsa/src/pdist.c |
fcdf | double fcdf(double x, int num,int den) {
double oup,k1,k2,y;
if (num <= 0 || den <= 0) {
printf("Degrees Of Freedom should be positive real integers");
exit(1);
}
if (x < 0.) {
printf("The range of distribution only takes non-negative and real values");
exit(1);
}
k1 = (double) num;
k2 = (double) d... | pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x471f0
testl %esi, %esi
jle 0x471f0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x471f9
cvtsi2sd %edi, %xmm2
cvtsi2sd %esi, %xmm3
mulsd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
jbe 0x471ce
divsd %xmm1, %xmm0
movsd 0xcc88(%rip), %xmm1 # ... | /rafat[P]ctsa/src/pdist.c |
finv | double finv(double p, int num,int den) {
double x,k1,k2,a,b;
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);
}
if (num <= 0 || den <= 0) {
printf("Degrees Of Freedom should be positive real integers");
exit(1);
}
k1 = (double) num;
k2 = (doubl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x472aa
ucomisd 0xbe71(%rip), %xmm0 # 0x530a0
ja 0x472aa
testl %edi, %edi
jle 0x472b3
testl %esi, %esi
jle 0x472b3
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
movsd %xmm1, -0x10(%rbp)
cvtsi2sd %esi, %xmm3
movsd %xmm3, -0x8(%rbp)
movs... | /rafat[P]ctsa/src/pdist.c |
gammapdf | double gammapdf(double x, double k, double th) {
double oup,t;
/*
* Gamma pdf = x ^ (k-1) * exp( - k/th) / (gamma(k) * theta ^k)
* Define t = x /th
* pdf = exp ((k-1) *log(t) - t - gamma_log(k)) /th
*/
if (k <= 0. || th <= 0.) {
printf("Gamma Distribution parameters must be positive and real.");
exit(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x47380
ucomisd %xmm2, %xmm0
jae 0x47380
divsd %xmm2, %xmm3
ucomisd %xmm0, %xmm3
jbe 0x47354
movsd 0xbdd7(%rip), %xmm0 # 0x530d8
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movapd %xmm3, %xmm0
movsd %xmm2, -0x... | /rafat[P]ctsa/src/pdist.c |
gammacdf | double gammacdf(double x, double k, double th) {
double oup,t;
if (k <= 0. || th <= 0.) {
printf("Gamma Distribution parameters must be positive and real.");
exit(1);
}
if (x <= 0.) {
x = 0.;
}
t = x/th;
oup = pgamma(t,k);
return oup;
} | xorpd %xmm3, %xmm3
ucomisd %xmm1, %xmm3
jae 0x473cf
ucomisd %xmm2, %xmm3
jae 0x473cf
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm3
cmplesd %xmm4, %xmm3
andnpd %xmm0, %xmm3
divsd %xmm2, %xmm3
movapd %xmm3, %xmm0
jmp 0x3af6c
pushq %rbp
movq %rsp, %rbp
leaq 0xe781(%rip), %rdi # 0x55b5b
xorl %eax, %eax
callq 0x60d0
movl $0x1... | /rafat[P]ctsa/src/pdist.c |
gammainv | double gammainv(double p, double k, double th) {
double oup,x,xi,del,mu,sigma2,cvar;
int m;
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);
}
if (k <= 0. || th <= 0.) {
printf("Gamma Distribution parameters must be positive and real.");
exit(1);
}
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, -0x10(%rbp)
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
ja 0x47613
ucomisd 0xbc8d(%rip), %xmm3 # 0x530a0
ja 0x47613
ucomisd -0x10(%rbp), %xmm0
jae 0x4761c
ucomisd %xmm2, %xmm0
jae 0x4761c
movsd 0xbc6a(%rip), %xmm1 # 0x530a0
cmpe... | /rafat[P]ctsa/src/pdist.c |
chipdf | double chipdf(double x, int df) {
double oup,k;
if (df <= 0 ) {
printf("Degree of freedom is a real positive integer");
exit(1);
}
if (x < 0.) {
printf("The range of distribution only takes non-negative and real values");
exit(1);
}
k = (double) df;
oup = gammapdf(x,k/2,2.);
return oup;
} | pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x47663
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x4766c
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
mulsd 0xc7eb(%rip), %xmm1 # 0x53e40
movsd 0xba5b(%rip), %xmm2 # 0x530b8
popq %rbp
jmp 0x472cb
leaq 0xe559(%rip), %rdi # 0x55bc3
jmp 0x47673
leaq 0xe472(%rip), %... | /rafat[P]ctsa/src/pdist.c |
chicdf | double chicdf(double x, int df) {
double oup,a;
if (df <= 0 ) {
printf("Degree of freedom is a real positive integer");
exit(1);
}
if (x < 0.) {
printf("The range of distribution only takes non-negative and real values");
exit(1);
}
a = (double) df;
oup = pgamma(x/2,a/2);
return oup;
} | pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x476b3
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x476bc
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
movsd 0xc79b(%rip), %xmm2 # 0x53e40
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
popq %rbp
jmp 0x3af6c
leaq 0xe509(%rip), %rdi # 0x55bc3
jmp 0x476c3
leaq 0xe422(%rip), %rd... | /rafat[P]ctsa/src/pdist.c |
chiinv | double chiinv(double p, int df) {
double x,k;
if (df <= 0 ) {
printf("Degree of freedom is a real positive integer");
exit(1);
}
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);
}
k = (double) df;
x = gammainv(p,k/2.,2.0);
return x;
} | pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x4770d
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x47716
ucomisd 0xb9b2(%rip), %xmm0 # 0x530a0
ja 0x47716
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
mulsd 0xc741(%rip), %xmm1 # 0x53e40
movsd 0xb9b1(%rip), %xmm2 # 0x530b8
popq %rbp
jmp 0x473eb
leaq 0xe4af(%rip),... | /rafat[P]ctsa/src/pdist.c |
fft_r2c_exec | void fft_r2c_exec(fft_real_object obj,fft_type *inp,fft_data *oup) {
fft_data* cinp;
fft_data* coup;
int i,N2,N;
fft_type temp1,temp2;
N2 = obj->cobj->N;
N = N2*2;
cinp = (fft_data*) malloc (sizeof(fft_data) * N2);
coup = (fft_data*) malloc (sizeof(fft_data) * N2);
for (i = 0; i < N2; ++i) {
cinp[i].re =... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, -0x38(%rbp)
movslq (%rax), %r15
movq %r15, -0x30(%rbp)
shlq $0x4, %r15
movq %r15, %rdi
callq 0x6190
movq %rax, %r14
movq %r15, %rdi
callq 0x6190... | /rafat[P]ctsa/src/real.c |
fft_c2r_exec | void fft_c2r_exec(fft_real_object obj,fft_data *inp,fft_type *oup) {
fft_data* cinp;
fft_data* coup;
int i,N2,N;
fft_type temp1,temp2;
N2 = obj->cobj->N;
N = N2*2;
cinp = (fft_data*) malloc (sizeof(fft_data) * N2);
coup = (fft_data*) malloc (sizeof(fft_data) * N2);
for (i = 0; i < N2; ++i) {
temp1 = -i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
movslq (%rax), %r12
movq %r12, -0x38(%rbp)
shlq $0x4, %r12
movq %r12, %rdi
callq 0x6190
movq %rax, %r14
movq %r12, %rdi
callq... | /rafat[P]ctsa/src/real.c |
ur_df | void ur_df(double *y, int N,const char* alternative, int *klag, double *statistic,double *pval) {
/*
y - Time Series data of length N
alternative - "stationary" or "explosive"
klag - Length of the lag. Uses pow((double)N - 1.0, 1.0/3.0) if klag == NULL
Outputs
statistic - Test statistic
pv... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %r9, -0xa8(%rbp)
movq %r8, -0x98(%rbp)
movq %rcx, %rbx
movq %rdx, -0xb0(%rbp)
movl %esi, %r14d
movq %rdi, -0x80(%rbp)
movabsq $0x4039000000000000, %rax # imm = 0x4039000000000000
movq %rax, ... | /rafat[P]ctsa/src/unitroot.c |
ur_kpss | void ur_kpss(double *y, int N,const char* type,int lshort, int *klag, double *statistic,double *pval) {
/*
y - Time Series data of length N
type - "level" or "trend"
lshort - determines the length of lag used. lshort = 1 => lag = 4.0 * pow(((double) N)/100.0,0.25)
else lag = 12.0 * pow(((double) N)/... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, -0x68(%rbp)
movq %r8, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
movq %rdx, %r12
movq %rdi, -0x30(%rbp)
movaps 0xd595(%rip), %xmm0 # 0x564b0
movaps %xmm0, -0x90(%rbp)
movapd 0xd576(%rip), %xmm0 # 0x564a0
movapd ... | /rafat[P]ctsa/src/unitroot.c |
ur_pp | void ur_pp(double *y, int N,const char* alternative,const char* type,int lshort, int *klag, double *statistic,double *pval) {
/*
y - Time Series data of length N
alternative - "stationary" or "explosive"
type - "Z(alpha)" or "Z(t_alpha)"
lshort - determines the length of lag used. lshort = 1 => lag ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp # imm = 0x3F8
movq %r9, -0xa8(%rbp)
movl %r8d, -0x38(%rbp)
movq %rcx, -0x88(%rbp)
movq %rdx, -0xa0(%rbp)
movl %esi, %ebx
movq %rdi, -0x78(%rbp)
movabsq $0x4039000000000000, %rax # imm = 0x4039000000000000
movq... | /rafat[P]ctsa/src/unitroot.c |
ur_pp2 | void ur_pp2(double *x, int N,const char* type,const char* model,int lshort, int *klag,double *cval,double *cprobs, double *auxstat,int *laux,double *teststat) {
/*
ur_pp2
C version of the R code by
Bernhard Pfaff [aut, cre], Eric Zivot [ctb], Matthieu Stigler [ctb]. urca: Unit Root and Cointegration Te... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r15
movq %rcx, %rbx
movq %rdx, -0x70(%rbp)
movq %rdi, %r12
xorl %r14d, %r14d
cmpl $0x1, %r8d
movq %rsi, -0x30(%rbp)
leal -0x1(%rsi), %eax
movl %eax, -0x50(%rbp)
cvtsi2sd %eax, %xmm0
sete %r14b
movsd %xmm0, -0x5... | /rafat[P]ctsa/src/unitroot.c |
decompose | void decompose(double *x,int N, int f,double *filter, const char *type, double *trend, int *ltrend, double *seas, int *lseas, double *random, int *lrandom) {
int isOdd,i,j,f2,clen,batches;
double *filt,*cout,*detrend,*seasonalmeans;
isOdd = f%2;
if (filter == NULL) {
filt = (double*) malloc(s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, -0xc0(%rbp)
movq %r8, %rbx
movl %edx, %r12d
movl %esi, -0x2c(%rbp)
movq %rdi, -0x48(%rbp)
movq 0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x20(%rbp), %rax
movq %rax... | /rafat[P]ctsa/src/seastest.c |
stl | void stl(double *x,int N,int f, const char *s_window_type,int *s_window, int *s_degree, int *t_window, int *t_degree,int *l_window,int *l_degree,
int *s_jump, int *t_jump, int *l_jump, int *robust,int *inner, int *outer,double *seasonal,double *trend, double *remainder) {
double *rw,*work;
int *seas_cy... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, -0x70(%rbp)
movl %edx, -0x30(%rbp)
cmpl $0x2, %edx
jl 0x4b22f
movl %edx, %r12d
movl %esi, %ebx
leal (%r12,%r12), %eax
movq %rax, -0x88(%rbp)
cmpl %esi, %eax
jg 0x4b22f
movq %r9, %r13
movq %r8, %r14
movq %rdi, %... | /rafat[P]ctsa/src/seastest.c |
modstl | void modstl(double *x, int N, int f, int *s_window,double *lambda, double *seasonal, double *trend,double *remainder) {
int i, s_window_;
double *y,*t;
s_window_ = (s_window == NULL) ? 13 : *s_window;
y = (double*)malloc(sizeof(double)*N);
if (lambda != NULL) {
boxcox(x,N,lambda,y);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %r13d
movq %rdi, -0x40(%rbp)
testq %rcx, %rcx
movl %edx, -0x30(%rbp)
je 0x4b27b
movl (%rcx), %eax
jmp 0x4b280
movl $0xd, %eax
movl %eax, -0x34(%rbp)
movslq %r13d, %r14
shlq $0x3, %... | /rafat[P]ctsa/src/seastest.c |
genLags | double* genLags(double *y, int N, int mlags, int *rows, int *cols) {
int i;
double *out;
if (mlags <= 0) {
out = (double*)calloc(N,sizeof(double));
*rows = 1;
*cols = N;
return out;
}
if (mlags == 1) {
out = (double*) malloc(sizeof(double)*N);
memcpy... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebx
testl %edx, %edx
jle 0x4b897
movl %edx, %r12d
movq %rdi, %r13
cmpl $0x1, %edx
jne 0x4b8ac
movl %ebx, -0x2c(%rbp)
movslq -0x2c(%rbp), %rbx
shlq $0x3, %rbx
movq %rbx, %rdi
call... | /rafat[P]ctsa/src/seastest.c |
fitOCSB | reg_object fitOCSB(double *x, int N, int f, int lag, int mlags) {
int i,j,Nyf,Ny, ylrows, ylcols,p;
double *y_fdiff, *y, *ylag, *mf, *res, *varcovar;
double *z4_y,*z4_lag,*z4_preds,*z4,*inp,*z5_y,*z5_lag,*z5_preds,*z5,*XX;
double *y2,*z5_y2;
int Nz4y,Nz5y,mfrows;
double alpha;
reg_object fit... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebx
movl %ecx, -0x38(%rbp)
movl %edx, -0x60(%rbp)
movq %rdi, %r13
movl %esi, -0x78(%rbp)
movslq %esi, %r15
leaq (,%r15,8), %r12
movq %r12, %rdi
callq 0x6190
movq %rax, %r14
movq %r12, -0xc0(%rbp)
movq %r12, %r... | /rafat[P]ctsa/src/seastest.c |
fft_exec | void fft_exec(fft_object obj,fft_data *inp,fft_data *oup) {
if (obj->lt == 0) {
//fftct_radix3_dit_rec(inp,oup,obj, obj->sgn, obj->N);
//fftct_mixed_rec(inp,oup,obj, obj->sgn, obj->N);
//printf("%f \n", 1.785);
int l,inc;
int nn,sgn1;
nn = obj->N;
sgn1 = obj->sgn;
l = 1;
inc = 0;
//radix3_dit_rec(o... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movl 0x10c(%rdi), %eax
cmpl $0x1, %eax
je 0x4d152
testl %eax, %eax
jne 0x4d140
movl (%rbx), %r8d
movl 0x4(%rbx), %ecx
movl $0x0, (%rsp)
movq %rdx, %rdi
movq %rbx, %rdx
movl $0x1, %r9d
callq 0x4d784
addq $0... | /rafat[P]ctsa/src/hsfft.c |
twiddle | void twiddle(fft_data *vec,int N, int radix) {
int K,KL;
fft_type theta,theta2;
theta = PI2/N;
KL = N/radix;
vec[0].re = 1.0;
vec[0].im = 0.0;
for (K = 1; K < KL;K++) {
theta2 = theta * K;
vec[K].re = cos(theta2);
vec[K].im = -sin(theta2);
}
} | movl %edx, %ecx
movl %esi, %eax
cltd
idivl %ecx
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rdi)
movq $0x0, 0x8(%rdi)
cmpl $0x2, %eax
jl 0x50f57
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
movsd 0x4cf7(%rip), %xmm1 #... | /rafat[P]ctsa/src/hsfft.c |
stlrwt_ | int stlrwt_(double *y, int *n, double *fit, double *rw)
{
/* System generated locals */
int i__1;
double d__1, d__2;
/* Local variables */
int i__;
double r__, c1, c9;
int mid[2];
double cmad;
int c__2 = 2;
/* Robustness Weights */
/* rw_i := B( |y_i - fit_i| / (6 M) ), i = 1,2,...... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, -0x30(%rbp)
movl (%rsi), %esi
testl %esi, %esi
jle 0x513c4
xorl %eax, %eax
movapd 0x1d79(%rip), %xmm0 # 0x53120
movsd (%r15,%rax,8), %xmm1
subsd (%r14,%rax,8)... | /rafat[P]ctsa/src/stl.c |
stless_ | int stless_(double *y, int *n, int *len, int *ideg, int *njump, int *userw, double *rw, double *ys,
double *res)
{
/* System generated locals */
int i__1, i__2, i__3;
double d__1;
/* Local variables */
int i__, j, k;
int ok;
int nsh;
double delta;
int nleft, newnj, nright;
/* Arg... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movq %rsi, %r15
movq 0x18(%rbp), %r14
movl (%rsi), %esi
cmpl $0x1, %esi
jg 0x514d1
movsd (%rdi), %xmm0
movsd %xmm0, (%r14)
jmp 0x51994
movq %rdi, -0x48(%rbp)
leaq -0x8(%r14), %... | /rafat[P]ctsa/src/stl.c |
stlest_ | int stlest_(double *y, int *n, int *len, int *ideg, double *xs, double *ys, int *nleft, int *
nright, double *w, int *userw, double *rw, int *ok)
{
/* System generated locals */
int i__1;
double d__1, d__2;
/* Local variables */
double a, b, c__, h__;
int j;
double r__, h1, h9, range;
/*... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x30(%rbp)
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, -0x50(%rbp)
movq 0x18(%rbp), %rax
cvtsi2sdl (%rsi), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x10(%rbp), %rcx
movsd (%r8), ... | /rafat[P]ctsa/src/stl.c |
stlfts_ | int stlfts_(double *x, int *n, int *np, double *trend, double *work)
{
/* System generated locals */
int i__1;
int c__3 = 3;
/* Parameter adjustments */
--work;
--trend;
--x;
/* Function Body */
stlma_(&x[1], n, np, &trend[1]);
i__1 = *n - *np + 1;
stlma_(&trend[1], &i__1, np,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
leaq -0x2c(%rbp), %rax
movl $0x3, (%rax)
callq 0x51d71
movl (%r13), %eax
subl (%r12), %eax
incl %eax
leaq -0x30(%rbp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movq %... | /rafat[P]ctsa/src/stl.c |
stlma_ | int stlma_(double *x, int *n, int *len, double *ave)
{
/* System generated locals */
int i__1;
/* Local variables */
int i__, j, k, m;
double v, flen;
int newn;
/* Moving Average (aka "running mean") */
/* ave(i) := mean(x{j}, j = max(1,i-k),..., min(n, i+k)) */
/* for i = 1,2,..,n *... | pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
movl (%rdx), %edx
subl %edx, %eax
cvtsi2sd %edx, %xmm0
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x51d96
xorl %esi, %esi
addsd (%rdi,%rsi,8), %xmm1
incq %rsi
cmpq %rsi, %rdx
jne 0x51d89
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx)
testl %eax, %eax
jle 0x51dd5
mov... | /rafat[P]ctsa/src/stl.c |
stlss_ | int stlss_(double *y, int *n, int *np, int *ns, int *isdeg, int *nsjump, int *userw, double *rw,
double *season, double *work1, double *work2, double *work3, double *work4)
{
/* System generated locals */
int i__1, i__2, i__3;
int c__1 = 1;
/* Local variables */
int i__, j, k, m;
int ok;
dou... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, -0x90(%rbp)
movq %rsi, -0x88(%rbp)
movl $0x1, -0x4c(%rbp)
movq %rdx, -0x68(%rbp)
movl (%rdx), %eax
movq %rax, -0x58(%rbp)
testl %eax, %eax
jle 0x52079
movq %rcx, %r13
movq 0x40(%rbp), %r10
movq 0x38(%rbp), %r11
... | /rafat[P]ctsa/src/stl.c |
psort_ | int psort_(double *a, int n, int *ind, int ni)
{
int i__, j, k, l, m, p;
double t;
int ij, il[16], jl, iu[16], ju;
int tt;
int indl[16], indu[16];
/* Partial Sorting ; used for Median (MAD) computation only */
/* Arg */
/* Var */
/* Parameter adjustments */
--a;
--ind;
/* Functio... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %eax
orl %esi, %eax
js 0x520b8
cmpl $0x2, %esi
setl %al
testl %ecx, %ecx
sete %r8b
orb %al, %r8b
je 0x520cc
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq... | /rafat[P]ctsa/src/stl.c |
stlez_ | void stlez_(double *y, int *n, int *np, int *ns, int *isdeg, int *itdeg,int *robust, int *no,
double *rw, double *season, double *trend, double *work)
{
/* System generated locals */
int work_dim1, work_offset, i__1, i__2;
double d__1;
/* Local variables */
int i__, j, ni, nl, nt;
double difs... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, -0x78(%rbp)
movq %rdx, %r14
movq %rsi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
xorl %r13d, %r13d
movl %r13d, -0x5c(%rbp)
movl $0x1, -0x58(%rbp)
movl (%rdx), %r12d
addl %r12d, %r12d
addl (%rsi), %r12d
movq %r9, -0x80(... | /rafat[P]ctsa/src/stl.c |
whisper_init_from_buffer_with_params | struct whisper_context * whisper_init_from_buffer_with_params(void * buffer, size_t buffer_size, struct whisper_context_params params) {
whisper_context * ctx = whisper_init_from_buffer_with_params_no_state(buffer, buffer_size, params);
if (!ctx) {
return nullptr;
}
ctx->state = whisper_init_st... | pushq %rbx
subq $0x30, %rsp
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x3e530
testq %rax, %rax
je 0x47f4e
movq %rax, %rbx
movq %rax, %rdi
callq 0x3faf0
movq %rax, 0x220(%rbx)
testq %rax, %rax
jne 0x47f50
movq %... | /ggerganov[P]whisper/src/whisper.cpp |
whisper_batch_prep_legacy(whisper_batch&, int const*, int, int, int) | static void whisper_batch_prep_legacy(whisper_batch & batch, const whisper_token * tokens, int n_tokens, int n_past, int seq_id) {
batch.n_tokens = n_tokens;
for (int i = 0; i < n_tokens; ++i) {
if (tokens) {
batch.token[i] = tokens[i];
}
batch.pos [i] = n_past + i;
... | movl %edx, (%rdi)
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
movl %ecx, %ecx
cmpq %rax, %r8
je 0x4897c
testq %rsi, %rsi
je 0x4894a
movl (%rsi,%rax,4), %r9d
movq 0x8(%rdi), %r10
movl %r9d, (%r10,%rax,4)
movq 0x10(%rdi), %r9
leal (%rcx,%rax), %r10d
movl %r10d, (%r9,%rax,4)
movq 0x18(%rdi), %r9
mov... | /ggerganov[P]whisper/src/whisper.cpp |
whisper_bench_memcpy_str | WHISPER_API const char * whisper_bench_memcpy_str(int n_threads) {
static std::string s;
s = "";
char strbuf[256];
ggml_time_init();
size_t n = 20;
size_t arr = n_threads > 0 ? 1024llu : n_threads; // trick to avoid compiler optimizations
// 1GB array
const size_t size = arr*1e6;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edi, %ebx
movb 0x3a3de(%rip), %al # 0x8a3f0
testb %al, %al
je 0x505ab
leaq 0x3a3af(%rip), %rdi # 0x8a3d0
leaq 0x1e476(%rip), %rsi # 0x6e49e
callq 0x41400
callq 0x3c5a0
testl %ebx, %ebx
movl $0... | /ggerganov[P]whisper/src/whisper.cpp |
get_alignment_heads_by_layer(whisper_context_params const&, int, int, int) | static std::vector<uint32_t> get_alignment_heads_by_layer(const whisper_context_params & cparams, int il, int n_text_layer, int n_head) {
std::vector<uint32_t> ret;
if (cparams.dtw_aheads_preset == WHISPER_AHEADS_NONE) {
return ret;
} else if (cparams.dtw_aheads_preset == WHISPER_AHEADS_N_TOP_MOST) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl 0xc(%rsi), %eax
testl %eax, %eax
je 0x50d70
movl %edx, %ebp
cmpl $0x2, %eax
je 0x50d82
cmpl $0x1, %eax
jne 0x50d88
subl 0x10(%rsi), %ecx
cmpl %ebp, %ecx
jle 0x5... | /ggerganov[P]whisper/src/whisper.cpp |
fft(float*, int, float*) | static void fft(float* in, int N, float* out) {
if (N == 1) {
out[0] = in[0];
out[1] = 0;
return;
}
const int half_N = N / 2;
if (N - half_N*2 == 1) {
dft(in, N, out);
return;
}
float* even = in + N;
for (int i = 0; i < half_N; ++i) {
even[i]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x1, %esi
jne 0x517cd
movss (%r14), %xmm0
movss %xmm0, (%rbx)
andl $0x0, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r15d
pushq $0x2
popq %... | /ggerganov[P]whisper/src/whisper.cpp |
whisper_build_graph_encoder(whisper_context&, whisper_state&) | static struct ggml_cgraph * whisper_build_graph_encoder(
whisper_context & wctx,
whisper_state & wstate) {
const auto & model = wctx.model;
const auto & hparams = model.hparams;
const int n_ctx = wstate.exp_n_audio_ctx > 0 ? wstate.exp_n_audio_ctx : hparams.n_audio_ctx;
const int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpq $0x0, 0x138(%rsi)
je 0x521a6
movq %rsi, %rbx
movq %rdi, %r12
movslq 0x54(%rdi), %rax
movslq 0x58(%rdi), %rcx
movq %rax, 0x10(%rsp)
cltd
movq %rcx, 0x30(%rsp)
idivl %ecx
movl %eax, (%rsp)
movl 0xa738(%rsi), %r14d
testl %r14d, %r14d
j... | /ggerganov[P]whisper/src/whisper.cpp |
iutest::detail::FormatIntWidthN[abi:cxx11](int, int) | inline ::std::string FormatIntWidthN(int value, int digit)
{
char buf[128] = { 0 };
int idx = IUTEST_PP_COUNTOF(buf) - 2;
int x = value;
for( int i=0; i < digit; ++i, --idx )
{
buf[idx] = static_cast<char>(::std::abs(x%10) + '0');
x /= 10;
}
for( ; x; --idx )
{
bu... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2a200
movl $0x7e, -0x94(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x98(%rbp)
movl $0x... | /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
vector_brodnik<int>::clear() | void clear()
{
for (unsigned i=0; i < _index_block.size(); ++i) {
free(_index_block[i]);
}
_index_block.clear();
_insertpos = 0;
_left_in_block = 0;
_left_in_superblock = InitialSuperBlocksize;
_block_size = InitialBlocksize;
_superblock_size = InitialSuperBlocksize;
_superblock = InitialSuperBloc... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
cmpq %rax, %rdx
je 0x23d90
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1d2a0
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x... | /rantala[P]string-sorting/unit-test/../src/vector_brodnik.h |
vector_bagwell<unsigned long, 16u>::clear() | void clear()
{
for (unsigned i=0; i < _index_block.size(); ++i) {
free(_index_block[i]);
}
_index_block.clear();
_insertpos = 0;
_left_in_block = 0;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
cmpq %rax, %rdx
je 0x247e2
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1d2a0
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x... | /rantala[P]string-sorting/unit-test/../src/vector_bagwell.h |
vector_block<unsigned long, 1024u>::push_back(unsigned long const&) | void push_back(const T& t)
{
if (__builtin_expect(is_full(), false)) {
_insertpos = static_cast<T*>(malloc(B*sizeof(T)));
_index_block.push_back(_insertpos);
_left_in_block = B;
}
*_insertpos++ = t;
--_left_in_block;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x24872
movq (%r14), %rcx
movq 0x18(%rbx), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x18(%rbx)
movq %rcx, (%rdx)
decl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1d508
m... | /rantala[P]string-sorting/unit-test/../src/vector_block.h |
void funnelsort<16u, buffer_layout_bfs>(unsigned char**, unsigned long, unsigned char**) | static void
funnelsort(unsigned char** strings, size_t n, unsigned char** restrict tmp)
{
debug() << __func__ << "(), n=" << n << "\n";
if (n < 32) {
insertion_sort(strings, n, 0);
return;
}
size_t splitter = n/K;
std::array<Stream, K> streams;
streams[0].stream = strings;
streams[0].n = splitter;
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc28, %rsp # imm = 0xC28
cmpq $0x1f, %rsi
ja 0x24f95
cmpq $0x2, %rsi
jb 0x2524b
movq %rdi, %rax
movq 0x8(%rax), %rcx
addq $0x8, %rax
movq %rax, %rdx
cmpq %rdi, %rax
jbe 0x24f81
movq %rax, %rdx
movq -0x8(%rdx), %r11
movb (%r11), %bl
movb... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<128u, 14u, buffer_layout_bfs>::operator()(std::array<Stream, 128ul>&, unsigned char**, std::array<unsigned long, 128ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, 0x18(%rsp)
leaq 0xe0(%rcx), %rbx
movq %rcx, (%rsp)
leaq 0xe8(%rcx), %rax
movq %rax, 0x20(%rsp)
leaq 0xe80(%rdx), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %rbx, 0x28(%rsp)
movq (%rbx),... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<8u, 2u, buffer_layout_dfs>::operator()(std::array<Stream, 8ul>&, unsigned char**, std::array<unsigned long, 8ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
leaq 0x20(%rcx), %rbx
movq %rcx, (%rsp)
leaq 0x28(%rcx), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rdx), %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, 0x20(%rsp)
movq (%rbx), ... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 4u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x40(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x48(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0xf8(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x40(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
xorl %... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 5u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x50(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x58(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x2870(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x27b8(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
xo... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 9u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x90(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x98(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x2458(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x1458(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
xo... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 17u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x110(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x118(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x12e8(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x12a8(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 23u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x170(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x178(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x4dc0(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x4d80(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<64u, 6u, buffer_layout_dfs>::operator()(std::array<Stream, 64ul>&, unsigned char**, std::array<unsigned long, 64ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x60(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x68(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x5028(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x4f70(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
xo... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<128u, 34u, buffer_layout_dfs>::operator()(std::array<Stream, 128ul>&, unsigned char**, std::array<unsigned long, 128ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x220(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x228(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x6170(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x6130(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<128u, 35u, buffer_layout_dfs>::operator()(std::array<Stream, 128ul>&, unsigned char**, std::array<unsigned long, 128ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x230(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0x238(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x6320(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x62e0(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
... | /rantala[P]string-sorting/src/funnelsort.cpp |
fill<128u, 15u, buffer_layout_dfs>::operator()(std::array<Stream, 128ul>&, unsigned char**, std::array<unsigned long, 128ul>&) const | void operator()(std::array<Stream,K>& restrict streams,
unsigned char** restrict buffer,
std::array<size_t,K>& restrict buffer_count) const
{
fill_inner<K,I,BufferLayout>(streams, buffer, buffer_count,
typename std::integral_constant<bool, (I>1 && I<K/2)>());
fill_leaf<K,I,B... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0xf0(%rcx), %rbx
movq %rcx, 0x8(%rsp)
leaq 0xf8(%rcx), %rax
movq %rax, 0x28(%rsp)
leaq 0x2b9b0(%rdx), %rax
movq %rax, 0x30(%rsp)
leaq 0x2b8b0(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
... | /rantala[P]string-sorting/src/funnelsort.cpp |
void msd_lsd<10u>(Cacheblock<10u>*, unsigned long, unsigned long) | static void
msd_lsd(Cacheblock<CachedChars>* cache, size_t N, size_t depth)
{
static_assert(CachedChars>=1, "CachedChars must be positive");
if (N < 32) {
insertion_sort(cache, N, depth);
return;
}
fill_cache(cache, N, depth);
for (int byte=CachedChars-1; byte >= 0; --byte) {
size_t bucketsize[256] = {0};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
movq %rdx, %r13
movq %rdi, %r14
cmpq $0x20, %rsi
jae 0x9b8f5
cmpq $0x2, %rsi
jae 0x9ba73
jmp 0x9badd
movq %rsi, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r13, 0x8(%rsp)
movq %r13, %rdx
callq 0x9b855
leaq (,%r1... | /rantala[P]string-sorting/src/msd_lsd.cpp |
void msd_D<vector_realloc<unsigned char*, 16u>, unsigned short>(unsigned char**, unsigned long, unsigned long, vector_realloc<unsigned char*, 16u>*) | static void
msd_D(unsigned char** strings, size_t n, size_t depth, Bucket* buckets)
{
if (n < 32) {
insertion_sort(strings, n, depth);
return;
}
// Use a small cache to reduce memory stalls.
size_t i=0;
for (; i < n-n%32; i+=32) {
unsigned char cache[32];
for (unsigned j=0; j < 32; ++j) {
cache[j] = str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdx, %rbx
cmpq $0x20, %rsi
jae 0xa393c
cmpq $0x2, %rsi
jb 0xa3ab9
leaq 0x1(%rbx), %rax
movq %rdi, %rcx
movq 0x8(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %r14
cmpq %rdi, %rcx
jbe 0xa3928
movq %rcx, %r14
movq ... | /rantala[P]string-sorting/src/msd_dyn_vector.cpp |
void msd_D<vector_malloc<unsigned char*, 16u>, unsigned short>(unsigned char**, unsigned long, unsigned long, vector_malloc<unsigned char*, 16u>*) | static void
msd_D(unsigned char** strings, size_t n, size_t depth, Bucket* buckets)
{
if (n < 32) {
insertion_sort(strings, n, depth);
return;
}
// Use a small cache to reduce memory stalls.
size_t i=0;
for (; i < n-n%32; i+=32) {
unsigned char cache[32];
for (unsigned j=0; j < 32; ++j) {
cache[j] = str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdx, %rbx
cmpq $0x20, %rsi
jae 0xa3b5c
cmpq $0x2, %rsi
jb 0xa3d06
leaq 0x1(%rbx), %rax
movq %rdi, %rcx
movq 0x8(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %r14
cmpq %rdi, %rcx
jbe 0xa3b48
movq %rcx, %r14
movq ... | /rantala[P]string-sorting/src/msd_dyn_vector.cpp |
void msd_D<vector_realloc_counter_clear<unsigned char*, 16u>, unsigned short>(unsigned char**, unsigned long, unsigned long, vector_realloc_counter_clear<unsigned char*, 16u>*) | static void
msd_D(unsigned char** strings, size_t n, size_t depth, Bucket* buckets)
{
if (n < 32) {
insertion_sort(strings, n, depth);
return;
}
// Use a small cache to reduce memory stalls.
size_t i=0;
for (; i < n-n%32; i+=32) {
unsigned char cache[32];
for (unsigned j=0; j < 32; ++j) {
cache[j] = str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdx, %rbx
cmpq $0x20, %rsi
jae 0xa3da9
cmpq $0x2, %rsi
jb 0xa3f15
leaq 0x1(%rbx), %rax
movq %rdi, %rcx
movq 0x8(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %r14
cmpq %rdi, %rcx
jbe 0xa3d95
movq %rcx, %r14
movq ... | /rantala[P]string-sorting/src/msd_dyn_vector.cpp |
void msd_D<vector_bagwell<unsigned char*, 16u>, unsigned short>(unsigned char**, unsigned long, unsigned long, vector_bagwell<unsigned char*, 16u>*) | static void
msd_D(unsigned char** strings, size_t n, size_t depth, Bucket* buckets)
{
if (n < 32) {
insertion_sort(strings, n, depth);
return;
}
// Use a small cache to reduce memory stalls.
size_t i=0;
for (; i < n-n%32; i+=32) {
unsigned char cache[32];
for (unsigned j=0; j < 32; ++j) {
cache[j] = str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdx, %rbx
cmpq $0x20, %rsi
jae 0xa4a1e
cmpq $0x2, %rsi
jb 0xa4c36
leaq 0x1(%rbx), %rax
movq %rdi, %rcx
movq 0x8(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %r14
cmpq %rdi, %rcx
jbe 0xa4a0a
movq %rcx, %r14
movq ... | /rantala[P]string-sorting/src/msd_dyn_vector.cpp |
vector_brodnik<unsigned char*>::~vector_brodnik() | ~vector_brodnik()
{
for (unsigned i=0; i < _index_block.size(); ++i) {
free(_index_block[i]);
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xa4cc6
movl $0x1, %ebp
xorl %eax, %eax
movq (%rdi,%rax,8), %rdi
callq 0x1d2a0
movl %ebp, %eax
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0xa4ca6
addq $0x8, %rsp
testq %rdi... | /rantala[P]string-sorting/src/vector_brodnik.h |
vector_bagwell<unsigned char*, 16u>::~vector_bagwell() | ~vector_bagwell()
{
for (unsigned i=0; i < _index_block.size(); ++i)
free(_index_block[i]);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xa4d10
movl $0x1, %ebp
xorl %eax, %eax
movq (%rdi,%rax,8), %rdi
callq 0x1d2a0
movl %ebp, %eax
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0xa4cf0
addq $0x8, %rsp
testq %rdi... | /rantala[P]string-sorting/src/vector_bagwell.h |
counting_list<unsigned char*>::clear() | void clear()
{
_size = 0;
std::list<T>::clear();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
movq (%rdi), %rdi
cmpq %rbx, %rdi
je 0xa5369
movq (%rdi), %r14
callq 0x1d200
movq %r14, %rdi
cmpq %rbx, %r14
jne 0xa5359
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /rantala[P]string-sorting/src/msd_dyn_vector.cpp |
vector_malloc<unsigned char*, 16u>::grow() | void grow()
{
if (_capacity == 0) {
_capacity = InitialSize;
_data = static_cast<T*>(malloc(_capacity*sizeof(T)));
} else {
_capacity <<= 1;
T* t = static_cast<T*>(malloc(_capacity*sizeof(T)));
(void) memcpy(t, _data, _size*sizeof(T));
free(_data);
_data = t;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa5415
leaq (%rdi,%rdi), %rax
movq %rax, 0x10(%rbx)
shlq $0x4, %rdi
callq 0x1d2e0
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1d1b0
movq %r15, %rdi
callq 0x1d2a0... | /rantala[P]string-sorting/src/vector_malloc.h |
vector_realloc_counter_clear<unsigned char*, 16u>::push_back(unsigned char* const&) | void push_back(const T& t)
{
if (_size == _capacity) { grow(); }
_data[_size] = t;
++_size;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jne 0xa546e
addq %rcx, %rcx
movl $0x10, %esi
cmovneq %rcx, %rsi
movq %rsi, 0x10(%rbx)
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x1d370
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
movq (%r14), %rdx
movq ... | /rantala[P]string-sorting/src/vector_realloc.h |
vector_block<unsigned char*, 1024u>::push_back(unsigned char* const&) | void push_back(const T& t)
{
if (__builtin_expect(is_full(), false)) {
_insertpos = static_cast<T*>(malloc(B*sizeof(T)));
_index_block.push_back(_insertpos);
_left_in_block = B;
}
*_insertpos++ = t;
--_left_in_block;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0xa559a
movq (%r14), %rcx
movq 0x18(%rbx), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x18(%rbx)
movq %rcx, (%rdx)
decl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1d63f
m... | /rantala[P]string-sorting/src/vector_block.h |
vector_block<unsigned char*, 1024u>::clear() | void clear()
{
for (size_t i=0; i < _index_block.size(); ++i) {
free(_index_block[i]);
}
_index_block.clear();
_insertpos=0;
_left_in_block=0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0xa55e2
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
callq 0x1d2a0
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0xa55c0
cmpq %rax, %rcx
je 0xa55... | /rantala[P]string-sorting/src/vector_block.h |
void insert<8000u, std::vector<unsigned char*, std::allocator<unsigned char*>>, BurstSimple<unsigned char>, unsigned char>(TrieNode<unsigned char>*, unsigned char**, unsigned long) | static inline void
insert(TrieNode<CharT>* root, unsigned char** strings, size_t n)
{
for (size_t i=0; i < n; ++i) {
unsigned char* str = strings[i];
size_t depth = 0;
CharT c = get_char<CharT>(str, 0);
TrieNode<CharT>* node = root;
while (node->is_trie[c]) {
assert(not is_end(c));
node = static_cast<T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
je 0xa5aa3
movq %rdi, %r15
xorl %ecx, %ecx
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xa5ad1
movq %rcx, 0x30... | /rantala[P]string-sorting/src/burstsort.cpp |
burstsort_brodnik(unsigned char**, unsigned long) | void burstsort_brodnik(unsigned char** strings, size_t n)
{
typedef unsigned char CharT;
typedef vector_brodnik<unsigned char*> BucketT;
typedef BurstSimple<CharT> BurstImpl;
//typedef BurstRecursive<CharT> BurstImpl;
TrieNode<CharT>* root = new TrieNode<CharT>;
insert<16000, BucketT, BurstImpl>(root, strings, n)... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x820, %edi # imm = 0x820
callq 0x1d250
movq %rax, %r15
movl $0x820, %edx # imm = 0x820
movq %rax, %rdi
xorl %esi, %esi
callq 0x1d120
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa5bfa
movq %r15, %rdi
movq %r14, %rsi... | /rantala[P]string-sorting/src/burstsort.cpp |
unsigned char** traverse<vector_brodnik<unsigned char*>, void (*)(unsigned char**, int, int), unsigned char>(TrieNode<unsigned char>*, unsigned char**, unsigned long, void (*)(unsigned char**, int, int)) | static unsigned char**
traverse(TrieNode<CharT>* node,
unsigned char** dst,
size_t depth,
SmallSort small_sort)
{
for (unsigned i=0; i < max<CharT>::value; ++i) {
if (node->is_trie[i]) {
dst = traverse<BucketT>(
static_cast<TrieNode<CharT>*>(node->buckets[i]),
dst, depth+sizeof(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
leaq 0x1(%rdx), %r15
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %r12, %rax
shrq $0x6, %rax
movq 0x800(%rbx,%rax,8), %rax
btq %r12, %rax
movq (%rbx,%r12,8), %r1... | /rantala[P]string-sorting/src/burstsort.cpp |
void insert<32000u, vector_block<unsigned char*, 128u>, BurstSimple<unsigned short>, unsigned short>(TrieNode<unsigned short>*, unsigned char**, unsigned long) | static inline void
insert(TrieNode<CharT>* root, unsigned char** strings, size_t n)
{
for (size_t i=0; i < n; ++i) {
unsigned char* str = strings[i];
size_t depth = 0;
CharT c = get_char<CharT>(str, 0);
TrieNode<CharT>* node = root;
while (node->is_trie[c]) {
assert(not is_end(c));
node = static_cast<T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0xa72bc
xorl %esi, %esi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%rsi,8), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0xa72ea
movzbl (%rax), %ecx
testw %cx, ... | /rantala[P]string-sorting/src/burstsort.cpp |
burstsort_sampling_vector(unsigned char**, unsigned long) | void burstsort_sampling_vector(unsigned char** strings, size_t n)
{
typedef unsigned char CharT;
typedef std::vector<unsigned char*> BucketT;
typedef BurstSimple<CharT> BurstImpl;
//typedef BurstRecursive<CharT> BurstImpl;
TrieNode<CharT>* root = pseudo_sample<CharT>(strings, n);
insert<8000, BucketT, BurstImpl>(... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa749e
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa5937
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa5af0
| /rantala[P]string-sorting/src/burstsort.cpp |
burstsort_sampling_brodnik(unsigned char**, unsigned long) | void burstsort_sampling_brodnik(unsigned char** strings, size_t n)
{
typedef unsigned char CharT;
typedef vector_brodnik<unsigned char*> BucketT;
typedef BurstSimple<CharT> BurstImpl;
//typedef BurstRecursive<CharT> BurstImpl;
TrieNode<CharT>* root = pseudo_sample<CharT>(strings, n);
insert<16000, BucketT, BurstI... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa749e
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa5bfa
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa5de7
| /rantala[P]string-sorting/src/burstsort.cpp |
burstsort_sampling_vector_block(unsigned char**, unsigned long) | void burstsort_sampling_vector_block(unsigned char** strings, size_t n)
{
typedef unsigned char CharT;
typedef vector_block<unsigned char*, 128> BucketT;
typedef BurstSimple<CharT> BurstImpl;
//typedef BurstRecursive<CharT> BurstImpl;
TrieNode<CharT>* root = pseudo_sample<CharT>(strings, n);
insert<16000, BucketT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
callq 0xa749e
movq %rax, %rdi
movq %rbx, 0x18(%rsp)
testq %rbx, %rbx
je 0xa7794
xorl %esi, %esi
movq %rdi, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax,%rsi,8), %rax
movq %rax, 0x30(%rsp)
testq %rax, %r... | /rantala[P]string-sorting/src/burstsort.cpp |
unsigned char** traverse<void (*)(unsigned char**, int, int), vector_brodnik<unsigned char*>, unsigned char>(TrieNode<unsigned char, vector_brodnik<unsigned char*>>*, unsigned char**, unsigned long, void (*)(unsigned char**, int, int)) | static unsigned char**
traverse(TrieNode<CharT, BucketT>* node,
unsigned char** dst,
size_t depth,
SmallSort small_sort)
{
for (unsigned i=0; i < node->_buckets.size(); ++i) {
if (node->is_trie(i)) {
dst = traverse(node->get_node(i),
dst, depth+sizeof(CharT), small_sort);
} else {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xa980f
movq %rdx, 0x18(%rsp)
leaq 0x1(%rdx), %rax
movq %rax, 0x28(%rsp)
xorl %r14d, %r14d
movq %rbx, 0x20(%rsp)
movq (%rdi,%r14,8), %rbp
testb $0x1, %bpl
jne 0xa9... | /rantala[P]string-sorting/src/burstsort2.cpp |
burstsort2_bagwell(unsigned char**, unsigned long) | void burstsort2_bagwell(unsigned char** strings, size_t n)
{
typedef unsigned char CharT;
typedef vector_bagwell<unsigned char*> BucketT;
typedef BurstSimple<CharT> BurstImpl;
TrieNode<CharT, BucketT>* root = new TrieNode<CharT, BucketT>;
insert<16384, BucketT, BurstImpl>(root, strings, n);
traverse(root, strings... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x1d250
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa9879
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x... | /rantala[P]string-sorting/src/burstsort2.cpp |
TrieNode<unsigned short, vector_bagwell<unsigned char*, 16u>>* BurstSimple<unsigned short>::operator()<vector_bagwell<unsigned char*, 16u>>(vector_bagwell<unsigned char*, 16u> const&, unsigned long) const | TrieNode<CharT, BucketT>*
operator()(const BucketT& bucket, size_t depth) const
{
TrieNode<CharT, BucketT>* new_node = new TrieNode<CharT, BucketT>;
const unsigned bucket_size = bucket.size();
// Use a small cache to reduce memory stalls. Also cache the
// string pointers, in case the indexing operation of th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x1d250
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xad4c7
movq 0x8(%r14), %rdx... | /rantala[P]string-sorting/src/burstsort2.cpp |
void multikey_simd<unsigned char>(unsigned char**, unsigned long, unsigned long) | static void
multikey_simd(unsigned char** strings, size_t N, size_t depth)
{
if (N < 32) {
insertion_sort(strings, N, depth);
return;
}
CharT partval = pseudo_median<CharT>(strings, N, depth);
uint8_t* const restrict oracle =
static_cast<uint8_t*>(_mm_malloc(N, 16));
std::array<size_t, 3> bucketsize;
bucket... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x1f, %rsi
ja 0xb1191
cmpq $0x2, %r15
jb 0xb131a
leaq 0x1(%rbx), %rax
movq %r14, %rcx
movq 0x8(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %rsi
cmpq %r14, %rcx
jbe 0xb117c
movq %rcx, %rsi
... | /rantala[P]string-sorting/src/multikey_simd.cpp |
loser_tree<unsigned char*>::min() | T min()
{
//debug() << __PRETTY_FUNCTION__ << std::endl;
assert(_nonempty_streams);
assert(not stream_empty(node2stream(0)));
T ret = *(node2stream(0).stream++);
if (--node2stream(0).n == size_t(0)) { --_nonempty_streams; }
update();
//debug() << "\t -> " << ret << std::endl;
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
je 0xcbbfa
movq %rdi, %rbx
xorl %esi, %esi
callq 0xcbd66
cmpq $0x0, 0x8(%rax)
je 0xcbc19
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcbd66
movq (%rax), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq (%rcx), %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcbd66
decq 0x8(... | /rantala[P]string-sorting/src/losertree.h |
loser_tree<unsigned char*>::update() | void update()
{
//debug() << __PRETTY_FUNCTION__ << std::endl;
unsigned new_min = _nodes[0];
for (unsigned i=(_stream_offset+new_min) >> 1; i!=0; i >>= 1) {
if (stream_empty(_streams[new_min]) or
(not stream_empty(node2stream(i)) and
cmp(*node2stream(i).stream,
*_streams[new_min].st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movl (%rax), %r14d
movl 0x14(%rdi), %ebp
addl %r14d, %ebp
cmpl $0x2, %ebp
jb 0xcbe4d
movq %rdi, %rbx
movl %ebp, %r15d
shrl %ebp
movq 0x8(%rbx), %rax
movl %r14d, %r12d
shlq $0x4, %r12
cmpq $0x0, 0x8(%rax,%r12)
je 0xcbe35
movq %rbx, %rdi
movl %ebp, ... | /rantala[P]string-sorting/src/losertree.h |
mergesort_lcp_3way_parallel(unsigned char**, unsigned long) | void
mergesort_lcp_3way_parallel(unsigned char** strings, size_t n)
{
debug() << __func__ << '\n';
lcp_t* lcp_input = (lcp_t*) malloc(n*sizeof(lcp_t));
lcp_t* lcp_tmp = (lcp_t*) malloc(n*sizeof(lcp_t));
unsigned char** input_tmp = (unsigned char**)
malloc(n*sizeof(unsigned char*));
#pragma omp parallel
{
#prag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %r15
leaq (,%rsi,8), %rbx
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, %r12
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
mergesort_cache1_lcp_2way(unsigned char**, unsigned long) | void mergesort_cache1_lcp_2way(unsigned char** strings, size_t n)
{ mergesort_cache_lcp_2way<unsigned char>(strings, n); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq (,%rsi,8), %rbx
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
callq 0x1d2e0
movq %rax, %r13
movq %r14, %rdi
callq 0x1d2e0
movq... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
void check_lcp_and_cache<unsigned char>(unsigned char*, unsigned char*, unsigned long, unsigned char, unsigned char*, unsigned long, unsigned char) | static void
check_lcp_and_cache(unsigned char* latest,
unsigned char* from0, lcp_t lcp0, CharT cache0,
unsigned char* from1, lcp_t lcp1, CharT cache1)
{
(void) latest;
(void) from0; (void) lcp0; (void) cache0;
(void) from1; (void) lcp1; (void) cache1;
/*debug()<<"******** CHE... | pushq %rax
movb (%rdi), %al
testb %al, %al
je 0xd1be2
xorl %r10d, %r10d
movl %eax, %r11d
cmpb (%rsi,%r10), %r11b
jne 0xd1bc6
movb 0x1(%rdi,%r10), %r11b
incq %r10
testb %r11b, %r11b
jne 0xd1bb3
cmpq %rdx, %r10
jne 0xd1c29
xorl %r10d, %r10d
cmpb (%r8,%r10), %al
jne 0xd1bea
movb 0x1(%rdi,%r10), %al
incq %r10
testb %al, %a... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
MergeResult mergesort_cache_lcp_2way<true, unsigned short>(unsigned char**, unsigned char**, unsigned long*, unsigned long*, unsigned short*, unsigned short*, unsigned long) | MergeResult
mergesort_cache_lcp_2way(
unsigned char** strings_input, unsigned char** strings_output,
lcp_t* restrict lcp_input, lcp_t* restrict lcp_output,
CharT* restrict cache_input, CharT* restrict cache_output,
size_t n)
{
debug() << __func__ << "(): n=" << n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rdi, %r12
movq 0xa0(%rsp), %r13
cmpq $0x1f, %r13
ja 0xd6e15
cmpq $0x2, %r13
jb 0xd6dcd
movl %r13d, %ecx
movq %r12, %rax
movq 0x8(%rax), %rdx
addq $0x8, %rax
movq %rax, %rsi
cmpq %r12, %rax
jbe 0xd6dc0... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
routine_cmp | static int
routine_cmp(const void *a, const void *b)
{
const struct routine *aa = *(const struct routine **)a;
const struct routine *bb = *(const struct routine **)b;
if (aa->f == bb->f)
return 0;
if (aa->multicore < bb->multicore)
return -1;
if (aa->multicore > bb->multicore)
return 1;
return strcmp(aa->na... | movq (%rdi), %rcx
movq (%rsi), %rdx
movq (%rcx), %rax
cmpq (%rdx), %rax
je 0xdd244
movb 0x18(%rcx), %sil
andb $0x1, %sil
movb 0x18(%rdx), %dil
andb $0x1, %dil
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb %dil, %sil
jb 0xdd243
movl $0x1, %eax
jbe 0xdd247
retq
xorl %eax, %eax
retq
movq 0x8(%rcx), %rdi
movq 0x8(%r... | /rantala[P]string-sorting/src/routines.c |
ssort2 | static void ssort2(string a[], int n, int depth)
{ int d, r, partval;
string *pa, *pb, *pc, *pd, *pl, *pm, *pn, t;
if (n < 10) {
insertsort(a, n, depth);
return;
}
pl = a;
pm = a + (n/2);
pn = a + (n-1);
if (n > 30) { /* On big arrays, pseudomedian of 9 */
d = (n/8)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xa, %esi
movl %edx, 0xc(%rsp)
jge 0xdfd65
cmpl $0x2, %ebx
jge 0xdffa4
jmp 0xe000f
movslq %edx, %rbp
leal 0x1(%rbp), %eax
movl %eax, 0x24(%rsp)
movq %r14, %r15
movl %ebx, %eax
shrl %eax
leaq (%r15,%r... | /rantala[P]string-sorting/external/multikey.c |
burstsortL | void
burstsortL(unsigned char *strings[], size_t scnt)
{
TRIE *root;
LIST *listnodes;
unsigned int i;
listnodes = (LIST *) calloc(scnt, sizeof(LIST));
for( i=scnt; i-- ;)
listnodes[i].word = strings[i];
root = (TRIE *) calloc(1, sizeof(TRIE));
(void) burstinsertL(root, listnodes,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x1d170
movq %r14, %rdx
movq %rax, %r14
testl %edx, %edx
je 0xe00d1
movl %edx, %eax
shlq $0x3, %rax
movq -0x8(%rbx,%rax), %rcx
movq %rcx, -0x10(%r14,%rax,2)
addq $-0x... | /rantala[P]string-sorting/external/burstsortL.c |
main | int main() {
#if (BOOST_DI_VERSION >= 1'0'0)
std::cout << "stable";
#else
std::cout << "unstable";
#endif
std::cout << " version of boost.di [" << BOOST_DI_VERSION << "]" << std::endl;
} | pushq %rbx
movq 0x2e24(%rip), %rbx # 0x3fd8
leaq 0xe49(%rip), %rsi # 0x2004
movq %rbx, %rdi
callq 0x1050
leaq 0xe41(%rip), %rsi # 0x200b
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
movl $0x82, %esi
callq 0x1070
leaq 0xe3c(%rip), %rsi # 0x2022
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x... | /boost-ext[P]di/example/configuration.cpp |
JPG::getHorizontalSamplingFrequency(unsigned int) const | uint getHorizontalSamplingFrequency(uint ID) const{
if(ID == 1) {
return YHorizontalSamplingFrequency;
} else if(ID == 2) {
return CbHorizontalSamplingFrequency;
} else if(ID == 3) {
return CrHorizontalSamplingFrequency;
} else
throw std::... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leal -0x1(%r14), %eax
cmpl $0x3, %eax
jae 0x281b
movl %eax, %eax
movzbl 0x35(%rdi,%rax,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
movl %r14d, %eax
leaq 0x18a6(%rip), %rsi # 0x40d6
addq %rax, %rsi
movq %rbx, ... | /Cheemion[P]JPEG_COMPRESS/Day4/include/JPG.h |
Catch::Detail::Approx::toString[abi:cxx11]() const | std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7a74a(%rip), %rax # 0x8e0b8
movq %rax, 0x28(%rsp)
callq 0x54b14
leaq 0x8(%rax), %rdi
callq 0x38840
movq %rax, %r14
movq %rax, 0x30(%rsp)
callq 0x54b14
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x38(%rsp)
leaq 0x5... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AssertionHandler::allowThrows() const | auto AssertionHandler::allowThrows() const -> bool {
return getCurrentContext().getConfig()->allowThrows();
} | pushq %rax
movq 0x7eaf0(%rip), %rdi # 0x92a40
testq %rdi, %rdi
je 0x13f5a
movq (%rdi), %rax
jmp 0x13f8e
movl $0x30, %edi
callq 0x125a0
movq %rax, %rdi
leaq 0x79ac2(%rip), %rax # 0x8da30
movq %rax, (%rdi)
leaq 0x79b08(%rip), %rcx # 0x8da80
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movu... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AssertionHandler::complete() | void AssertionHandler::complete() {
setCompleted();
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
// call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test and... | pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x3a(%rdi)
cmpb $0x1, 0x38(%rdi)
jne 0x13fb4
callq 0x1b528
testb %al, %al
je 0x13fb4
int3
cmpb $0x1, 0x39(%rbx)
je 0x13fbc
popq %rbx
retq
movl $0x1, %edi
callq 0x122a0
leaq 0x79943(%rip), %rsi # 0x8d910
movq %rax, %rdi
xorl %edx, %edx
callq 0x129e0
nop
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AssertionResultData::reconstructExpression[abi:cxx11]() const | std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) {
if( lazyExpression ) {
ReusableStringStream rss;
rss << lazyExpression;
reconstructedExpression = rss.str();
}
}
retur... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x28(%rsi), %rdx
testq %rdx, %rdx
jne 0x143d4
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x143d2
leaq 0x40(%r15), %r13
leaq 0x79d6a(%rip), %rax # 0x8e0b8
movq %rax, 0x8(%rsp)
callq 0x54b14
leaq 0x8(%rax)... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AssertionResult::getExpression[abi:cxx11]() const | std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.c... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x12900
testb $0x4, 0x30(%r14)
je 0x14551
leaq 0x512a0(%rip), %rsi # 0x657e9
movq %rbx, %rdi
callq 0x12b10
movq 0x20(%r14), ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AssertionResult::hasExpandedExpression() const | constexpr auto empty() const noexcept -> bool {
return m_size == 0;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x146fd
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x14772
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x14510
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x14701
movq 0x28(%rsp), %r14
testq %rdx, %rdx
je 0x1470a
movq 0x8(%rsp), %rdi
mo... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&) | std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
os << info.file << '(' << info.line << ')';
#else
os << info.file << ':' << info.line;
#endif
return os;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x1a8e6
movq %r15, %rdi
callq 0x12250
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x126a0
jmp 0x1a8fd
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %e... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( sta... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4ba85(%rip), %r12 # 0x666fd
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x129a0
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x12940
cmpq $-0x1, %r15
je 0... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Detail::parseEnums(Catch::StringRef) | std::vector<StringRef> parseEnums( StringRef enums ) {
auto enumValues = splitStringRef( enums, ',' );
std::vector<StringRef> parsed;
parsed.reserve( enumValues.size() );
for( auto const& enumValue : enumValues ) {
parsed.push_back(trim(extractInstanceName... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x2c, %ecx
callq 0x1b8b5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x37618
movq (%rsp)... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::splitStringRef(Catch::StringRef, char) | std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
std::vector<StringRef> subStrings;
std::size_t start = 0;
for(std::size_t pos = 0; pos < str.size(); ++pos ) {
if( str[pos] == delimiter ) {
if( pos - start > 1 )
subStrings.p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1b966
movl %ecx, %ebp
leaq 0x4a5d7(%rip), %r12 # 0x65ec3
xorl %r13d, %r13d
xorl %eax, %eax
cmpb %bpl,... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ExceptionTranslatorRegistry::registerTranslator(Catch::IExceptionTranslator const*) | void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
} | pushq %rbx
subq $0x10, %rsp
addq $0x8, %rdi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x45a34
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd25
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd3e
movq (%rdi), %rax
callq *0... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const | std::string ExceptionTranslatorRegistry::translateActiveException() const {
try {
#ifdef __OBJC__
// In Objective-C try objective-c exceptions first
@try {
return tryTranslators();
}
@catch (NSException *exception) {
return Catch::D... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x12650
cmpq $0x0, (%r15)
je 0x1bd7b
movq %rsp, %rdi
callq 0x124e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1beb0
jmp 0x1bd98
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a245(%rip), %rsi # 0x65... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::FatalConditionHandler::FatalConditionHandler() | FatalConditionHandler::FatalConditionHandler() {
assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
if (altStackSize == 0) {
altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
}
altStackMem = new char[altStack... | pushq %r14
pushq %rbx
pushq %rax
movb $0x0, (%rdi)
cmpq $0x0, 0x76b3b(%rip) # 0x92a58
jne 0x1bf72
movq 0x76b3a(%rip), %rbx # 0x92a60
testq %rbx, %rbx
jne 0x1bf4b
movl $0xfa, %edi
callq 0x12380
cmpq $0x8001, %rax # imm = 0x8001
movl $0x8000, %ebx # imm = 0x8000
cmovaeq %rax, %rbx
movq %rbx, 0... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::GroupInfo::GroupInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | GroupInfo::GroupInfo( std::string const& _name,
std::size_t _groupIndex,
std::size_t _groupsCount )
: name( _name ),
groupIndex( _groupIndex ),
groupsCounts( _groupsCount )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x434f2
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
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.