name string | code string | asm string | file string |
|---|---|---|---|
stopcheck | int stopcheck(double fx,int N,double *xc,double *xf,double *jac,double *dx,double fsval,double gtol,double stol,int retval) {
int rcode,i;
double num,den;
double stop0;
double *scheck;
rcode = 0;
if (retval == 1) {
rcode = 3;
return rcode;
}
if (retval == 5) {
rcode = 5;
return rcode;
}
if (retval ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm2, -0x48(%rbp)
movsd %xmm3, -0x50(%rbp)
movl %r9d, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0x1, -0x54... | /rafat[P]ctsa/src/newtonmin.c |
newton_min_trust | int newton_min_trust(custom_function *funcpt, custom_gradient *funcgrad, double *xi, int N, double *dx, double fsval, double delta,
int method,int MAXITER,int *niter,double eps,double gtol,double stol,double *xf) {
int rcode,iter,gfdcode,hdcode;
int i,siter,retval,fdiff;
double dt1,dt2,eps2,eps3;
double fx,num,de... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x48(%rbp... | /rafat[P]ctsa/src/newtonmin.c |
fminsearch | int fminsearch(custom_function *funcpt,int N,double *xi,double *xf) {
int i,retval,MAXITER,niter;
double fsval,eps;
double *dx;
dx = (double*) malloc(sizeof(double) * N);
fsval = 1.0;
MAXITER = 200*N;
niter = 0;
eps = macheps(); // Use macheps program
for(i = 0; i < N;++i) {
dx[i] = 1.0;
}
retval = nel... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x48(%rbp)
movsd 0x3f818(%rip), %xmm0 # 0x77078
movsd %xmm0, -0x38(%rbp)
imull $0xc8, -0xc(%rbp), %eax
movl %eax, -0x2... | /rafat[P]ctsa/src/optimc.c |
fminunc | int fminunc(custom_function *funcpt, custom_gradient *funcgrad, int N, double *xi,double maxstep, int method,double *xf) {
int i,retval,MAXITER,niter,m;
double fsval,eps,gtol,stol,ftol,xtol,delta;
double *dx;
dx = (double*) malloc(sizeof(double) * N);
/*
* Method 0 - Nelder-Mead
* Method 1 - Newton Line Se... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x90(%rbp)
movsd 0x3f735(%rip), %xmm0 # 0x7707... | /rafat[P]ctsa/src/optimc.c |
mvalue | static int mvalue(int N) {
int mval;
if (N <= 10) {
mval = N;
} else if (N > 10 && N <= 20) {
mval = 10;
} else if (N > 20 && N <= 200) {
mval = 15;
} else if ( N > 200) {
mval = 20;
}
return mval;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jg 0x37ea5
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x37ee8
cmpl $0xa, -0x4(%rbp)
jle 0x37eba
cmpl $0x14, -0x4(%rbp)
jg 0x37eba
movl $0xa, -0x8(%rbp)
jmp 0x37ee6
cmpl $0x14, -0x4(%rbp)
jle 0x37ed2
cmpl $0xc8, -0x4(%rbp)
jg 0x37ed2
movl $0xf, ... | /rafat[P]ctsa/src/optimc.c |
levmar | int levmar(custom_funcmult *funcmult, custom_jacobian *jacobian,
double *xi,int M, int N,double *xf) {
int info,i;
double *fvec,*fjac,*diag,*qtf;
int ldfjac,mode,nfev,njev,nprint,maxfev;
int *ipvt;
double factor,eps,epsfcn,ftol,gtol,xtol;
fvec = (double*) malloc(sizeof(double) *M);
fjac = (double*) malloc(siz... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movl %r8d, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movslq -0x44(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq... | /rafat[P]ctsa/src/optimc.c |
FXSHFT | static void FXSHFT(int NN, int L2, double *ZR, double *ZI, int *CONV, double *SR, double *SI, double *PR, double *PI, double *QPR, double *QPI, double *PVR, double *PVI,
double ARE, double MRE, double ETA, double INFIN, double *HR, double *HI, double *QHR, double *QHI, double *SHR, double *SHI, double *TR, double *TI)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq 0x80(%rbp), %rax
movq 0x78(%rbp), %rax
movq 0x70(%rbp), %rax
movq 0x68(%rbp), %rax
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %r... | /rafat[P]ctsa/src/polyroot.c |
cpolyroot | int cpolyroot(double *rcoeff,double *icoeff, int DEGREE, double *ZEROR, double *ZEROI) {
/*
Input - rcoeff[0]+i*icoeff[0] + (rcoeff[1] + i*icoeff[1]) * x^1 + (rcoeff[2] + i*icoeff[2]) * x^2 + ---- + (rcoeff[DEGREE+1] + i*icoeff[DEGREE+1]) * x^DEGREE
The program fails if there are leading zeros [At least one coeffic... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x40(%rbp)
movslq -0x34(%rbp), %rdi... | /rafat[P]ctsa/src/polyroot.c |
POLYEV | static void POLYEV(int NN, double *SR, double *SI,double *PR, double *PI, double *QR, double *QI, double *PVR, double *PVI) {
double T;
int i;
QR[0] = PR[0];
QI[0] = PI[0];
*PVR = QR[0];
*PVI = QI[0];
for (i = 1; i < NN; ++i) {
T = *PVR * *SR - *PVI * *SI + PR[i];
*PVI = *PVR * *SI + *PVI * *SR + PI[i];
*... | pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -... | /rafat[P]ctsa/src/polyroot.c |
reg_init | reg_object reg_init(int N, int p) {
reg_object obj = NULL;
int i;
/*
* reg_init initializes the regression object.
* N - number of observation samples. All variables (indepnedent and dependent)
* are of identical length N.
*
* p - Total Number of variables (independent and dependent).
* The base case is p = 2 ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x3bea2
leaq 0x3c8ad(%rip), %rdi # 0x78730
movb $0x0, %al
callq 0x60a0
leaq 0x3c8eb(%rip), %rdi # 0x7877c
movb $0x0, %al
callq 0x60a0
movl $0x1, %edi
callq 0x61e0
movl -0x8(%r... | /rafat[P]ctsa/src/regression.c |
linreg_clrm | void linreg_clrm(double *x, double *y, int N, double* b,
double *var, double *res, double alpha, double *anv,
double* ci_lower, double* ci_upper) {
int i, df;
double *xi;
double *yi;
double xm, ym, num, den, sum, den2, den3;
double seb1, seb2, a2, ta2, intrvl, chia2, chi1a2;
/*
* Classic Linear Regression Mod... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6... | /rafat[P]ctsa/src/regression.c |
setIntercept | void setIntercept(reg_object obj, int intercept) {
if (intercept == 1 && obj->p > 0) {
obj->intercept = 1;
}
else if (intercept == 0) {
obj->intercept = 0;
//obj->p = obj->p - 1;
}
else {
printf("The variable intercept only accepts 0 or 1 values. Additionally, Intercept is 0 when p == 0. \n");
exit(-1);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x3d81c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x3d81c
movq -0x8(%rbp), %rax
movl $0x1, 0x58(%rax)
jmp 0x3d849
cmpl $0x0, -0xc(%rbp)
jne 0x3d82f
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
jmp 0x3d8... | /rafat[P]ctsa/src/regression.c |
regress_poly | void regress_poly(reg_object obj, double *x, double *y, double *res, double *varcovar, double alpha) {
int polydeg, i, j, sum;
double *xx;
/*
* Performs polynomial regression of the form
* Y = B0 + B1 * X + B2 * X^2 + ..... + B(p-1) * X ^(p-1)
*
* where p is defined as in regular regression
* p = Number of depe... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x3dfaa
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
... | /rafat[P]ctsa/src/regression.c |
anova | void anova(reg_object obj) {
printf("\n");
printf("ANOVA : \n");
printf("%-25s%-20s%-20s%-20s \n", "Source of Variation", "df", "SS", "MSS");
printf("%-25s%-20d%-20lf%-20lf \n", "Due to Regression",
obj->df_ESS, obj->ESS, obj->ESS / ((double)obj->df_ESS));
printf("%-25s%-20d%-20lf%-20lf \n", "Due to Residual",
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x38e3d(%rip), %rdi # 0x77030
movb $0x0, %al
callq 0x60a0
leaq 0x3a878(%rip), %rdi # 0x78a79
movb $0x0, %al
callq 0x60a0
leaq 0x3a92b(%rip), %rdi # 0x78b3a
leaq 0x3a86d(%rip), %rsi # 0x78a83
leaq 0x393f1(%rip), %rdx # 0x7760e
lea... | /rafat[P]ctsa/src/regression.c |
confint | void confint(reg_object obj) {
int i;
printf("\n");
printf("%-10lf%% Confidence Interval For Parameters And Residual Variance : \n", (1.0 - obj->alpha) * 100);
printf("%-25s%-20s%-20s%-20s \n", "Parameters",
"Value", "Lower Limit", "Upper Limit");
for (i = 0; i < obj->p; ++i) {
printf("B%-25d%-20lf%-20lf%-20l... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x38bdd(%rip), %rdi # 0x77030
movb $0x0, %al
callq 0x60a0
movq -0x8(%rbp), %rax
movsd 0x38c12(%rip), %xmm0 # 0x77078
subsd 0x8(%rax), %xmm0
movsd 0x39d4d(%rip), %xmm1 # 0x781c0
mulsd %xmm1, %xmm0
leaq 0x3a71f(%rip), %rdi # 0x78b9d
movb... | /rafat[P]ctsa/src/regression.c |
fitted | double fitted(reg_object obj, double *inp, double *varcovar, double *var) {
int i, p;
double oup;
double *y, *x0, *b, *temp;
/*
* The function predicts output value at a given input point (vector of size p-1)
*
* inp - ia a vector of length p-1 values corresponding to each of the p-1
* dependent variables.
* ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x8, %edi
callq 0x6160
movq %rax, -0x38(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0... | /rafat[P]ctsa/src/regression.c |
bfgs_naive | void bfgs_naive(double *H,int N,double eps,double *xi,double *xf,double *jac,double *jacf) {
int i,j,supd,ct;
double sn,yn,fd,yt,jacm;
double *sk,*yk,*temp,*temp2,*t;
sk = (double*) malloc(sizeof(double) *N);
yk = (double*) malloc(sizeof(double) *N);
temp = (double*) malloc(sizeof(double) *1);
temp2 = (double*... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x78(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
c... | /rafat[P]ctsa/src/secant.c |
inithess_naive | static void inithess_naive(double *H,int N,double fi,double fsval,double *dx) {
int i,j,ct;
double temp;
if (fabs(fi) > fsval) {
temp = fabs(fi);
} else {
temp = fsval;
}
for(i = 0; i < N;++i) {
ct = i *N;
for(j = 0; j < N;++j) {
if (i == j) {
H[ct+j] = temp * dx[i] * dx[i];
} else {
H[c... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x37cab(%rip), %xmm1 # 0x770e0
pand %xmm1, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x3f457
movsd -0x18(%rbp), %xmm0
movaps 0x37c94(%rip), %xmm1 ... | /rafat[P]ctsa/src/secant.c |
psiweight | void psiweight(double *phi,double *theta,double *psi,int p,int q,int j) {
int i,k;
double temp;
double *th;
psi[0] = 1.0;
th = (double*) malloc(sizeof(double) * (q+1));
th[0] = 1.;
for(i = 0; i < q;++i) {
th[i+1] = theta[i];
}
for(i = 1; i < j;++i) {
psi[i] = 0.0;
temp = 0.0;
if(i <= q) {
psi[i] ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movsd 0x33edd(%rip), %xmm0 # 0x77078
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi... | /rafat[P]ctsa/src/talg.c |
piweight | void piweight(double *phi,double *theta,double *piw,int p,int q,int j) {
int i,k;
double temp;
double *ph;
piw[0] = 1.0;
ph = (double*) malloc(sizeof(double) * (p+1));
ph[0] = -1.;
for(i = 0; i < p;++i) {
ph[i+1] = phi[i];
}
for(i = 1; i < j;++i) {
piw[i] = 0.0;
temp = 0.0;
if(i <= p) {
piw[i] = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movsd 0x33d5d(%rip), %xmm0 # 0x77078
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi... | /rafat[P]ctsa/src/talg.c |
arma_autocovar | void arma_autocovar(double *phi,double *theta,int p,int q,double var,double* acov, int lag) {
int i,j,t,m;
double *tcov,*psi,*A,*b,*ph,*th,*thph;
int *ipiv;
int p1;
double temp;
p1 = p+1;
tcov = (double*) malloc(sizeof(double) * (p1));
ipiv = (int*) malloc(sizeof(int) * (p1));
A = (double*) malloc(sizeof(dou... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
movslq -0x84(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160... | /rafat[P]ctsa/src/talg.c |
twacf | int twacf(double *P, int MP, double *Q, int MQ, double *ACF, int MA, double *CVLI, int MXPQ1, double *ALPHA, int MXPQ) {
int ifault, i, k, kc, j, jpk, kcp1mj, j1, kp1, kp2mj, miim1p, imj, mikp, kp1mj;
double epsil2, zero, one, half, two, div;
ifault = 0;
epsil2 = 1.0e-10;
zero = 0.0; half = 0.5, one = 1.0, two = ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movsd 0x34402(%rip), %xmm0 ... | /rafat[P]ctsa/src/talg.c |
archeck | int archeck(int p, double *ar) {
int check, N, i;
double *coeff,*zeror,*zeroi,mod,wmaxv;
int *which,wmax;
N = p + 1;
check = 1;
coeff = (double*)malloc(sizeof(double)*N);
zeror = (double*)malloc(sizeof(double)*p);
zeroi = (double*)malloc(sizeof(double)*p);
which = (int*)malloc(sizeof(int)*N);
coeff[0] = 1.... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movslq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x28(%rbp)
movslq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x30(... | /rafat[P]ctsa/src/talg.c |
invertroot | int invertroot(int q, double *ma) {
int i, index, retval, fail, rcheck, qn, i1, j;
double *temp, *zeror, *zeroi, *xr, *xi,*yr,*yi;
int *ind;
double mod,tempr,tempi;
retval = 0;
index = -1;
for (i = 0; i < q; ++i) {
if (ma[i] != 0.0) {
index = i;
}
}
if (index == -1) {
return retval;
}
temp = (d... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x44ccc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorp... | /rafat[P]ctsa/src/talg.c |
interpolate_linear | double interpolate_linear(double *xin,double *yin, int N, double z) {
int i,j,k;
double *x,*y;
int *pos;
double out,ylo,yhi;
x = (double*)malloc(sizeof(double)*N);
y = (double*)malloc(sizeof(double)*N);
pos = (int*)malloc(sizeof(int)*N);
sort1d_ascending(xin,N,pos);
for(i = 0; i < N;++i) {
x[i] = xin[pos[... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x48(%rbp)
movslq -0x1c(%rbp), %rdi
shl... | /rafat[P]ctsa/src/talg.c |
linspace | void linspace(double *x, int N,double xlo,double xhi) {
int i;
double intv;
intv = (xhi - xlo)/(double)(N-1);
x[0] = xlo;
x[N-1] = xhi;
for(i = 1; i < N-1;++i) {
x[i] = xlo + intv * (double) i;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax... | /rafat[P]ctsa/src/talg.c |
approx | void approx(double *x,double *y, int N,double *xout, double *yout,int Nout) {
int i;
/* x and y should be sorted in ascending order. x has all unique values
xout contains equally spaced Nout values from lowest x[0]
to highest x[N-1].Outputs y[out] are Nout interpolated values.
*/
for(i = 0; i < Nout;++i)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x459cf
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax... | /rafat[P]ctsa/src/talg.c |
ppsum | void ppsum(double* u, int n, int l, double* sum)
{
/* Copyright (C) 1997-2000 Adrian Trapletti
efficient computation of the sums involved in the Phillips-Perron tests */
int i, j;
double tmp1, tmp2;
//printf("%d %d %g \n ",n,l,*sum);
tmp1 = 0.0;
for (i=1; i<= l; i++)
{
tmp2 = 0.0;
for (j=i; ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x45d9c
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -... | /rafat[P]ctsa/src/talg.c |
supsmu | void supsmu(double *x, int N, double *y,double *w, int periodic,double span, double alpha,double *oup) {
/* input: */
/* N : number of observations (x,y - pairs). */
/* x(N) : ordered abscissa values. */
/* y(N) : corresponding ordinate (response) values. */
/* w(N) : weight for each (x,y) observation.... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movq %r9, -0x40(%rbp)
imull $0x7, -0xc(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x60f0
movq %rax, -0x4... | /rafat[P]ctsa/src/talg.c |
supsmu_ | static int supsmu_(int *n, double *x, double *y, double *w, int *iper, double *span, double *alpha, double *smo, double *sc)
{
/* System generated locals */
int sc_dim1, sc_offset, i__1;
double r__1, r__2;
double d__1, d__2;
/* Local variables */
double a, f, h__;
int i__, j;
double sw,... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c... | /rafat[P]ctsa/src/talg.c |
smooth_ | static int smooth_(int *n, double *x, double *y, double *w, double *span, int *iper, double *vsmlsq, double *smo, double *acvr)
{
/* System generated locals */
int i__1;
double r__1;
double d__1;
/* Local variables */
double a, h__;
int i__, j, j0, in, it;
double xm, ym, wt, sy, fbo, fb... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x20(%rbp), %rax
addq $-0x8, %rax
movq %rax, 0x20(%rbp)
movq 0x18(%rbp... | /rafat[P]ctsa/src/talg.c |
ndiffs | int ndiffs(double *x, int N,double *alpha, const char *test,const char *type, int *max_d) {
int d,max_d_,cc,NX,dodiff;
double alpha_;
double *y,*z;
d = 0;
alpha_ = alpha == NULL ? 0.05 : *alpha;
max_d_ = max_d == NULL ? 2 : *max_d;
// printf("%g \n",alpha_);
if (max_d_ < 0) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4746f
movsd 0x2fc20(%rip), %xmm0 # 0x77088
movsd %xmm0, -0x70(%rbp)
jmp 0x4747c
movq ... | /rafat[P]ctsa/src/autoutils.c |
runstattests | static int runstattests(double *x, int N, const char * test,const char *mtype,double alpha) {
int diff,klag,lshort;
const char *alternative;
const char *type;
const char *model;
const char *selectlags;
double stat, pval;
double cval[9] = {0,0,0,0,0,0,0,0,0};
double cprobs[3] = {0,0,0};
dou... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x60b0
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
mov... | /rafat[P]ctsa/src/autoutils.c |
nsdiffs | int nsdiffs(double *x, int N,int f,double *alpha, const char *test, int *max_D) {
int D,max_D_,cc,NX,dodiff;
double alpha_;
double *y,*z;
D = 0;
alpha_ = alpha == NULL ? 0.05 : *alpha;
max_D_ = max_D == NULL ? 1 : *max_D;
if (max_D_ < 0) {
printf("Error. Maximum Difference cannot... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47aab
movsd 0x2f5e4(%rip), %xmm0 # 0x77088
movsd %xmm0, -0x68(%rbp)
jmp 0x47ab8
movq ... | /rafat[P]ctsa/src/autoutils.c |
runseasonalitytests | static int runseasonalitytests(double *x, int N,int f, const char * test) {
int diff,mlags;
double stat,crit;
const char *method;
if (!strcmp(test,"ocsb")) {
mlags = 3;
method = "aic";
OCSBtest(x,N,f,mlags,method,&stat,&crit);
diff = (stat > crit) ? 1 : 0;
} else if ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2f976(%rip), %rsi # 0x77677
callq 0x6100
cmpl $0x0, %eax
jne 0x47d5c
movl $0x3, -0x20(%rbp)
leaq 0x2f4b0(%rip), %rax # 0x771c9
movq %rax, -0x38(%rbp... | /rafat[P]ctsa/src/autoutils.c |
is_constant | int is_constant(double *x, int N) {
int i, cst;
double eps,tmp;
eps = macheps();
cst = 1;
for(i = 1; i < N;++i) {
tmp = x[i] - x[i-1];
if (fabs(tmp) > eps) {
return 0;
}
}
return cst;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb $0x0, %al
callq 0x24940
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x47e42
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xm... | /rafat[P]ctsa/src/autoutils.c |
checkConstant | int checkConstant(double *x, int N) {
int i, cc;
double diff;
cc = 0;
/// heap buffer overflow fix, since accessing x[i+1] need to
/// stop loop at -1 index from end of array as dictated by length defined by N
for(i = 1; i < N - 1;++i) {
diff = x[i+1] - x[i];
if (fabs(diff) > 0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x47ed8
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq... | /rafat[P]ctsa/src/boxcox.c |
boxcox_eval | void boxcox_eval(double *x, int N, double lambda,double *bxcx) {
double eps;
int i;
eps = macheps() / 744.44;
if (fabs(lambda) < eps) {
for(i = 0; i < N;++i) {
bxcx[i] = log(x[i]);
}
} else {
for(i = 0; i < N;++i) {
bxcx[i] = expm1(lambda * log(x[i])... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, %al
callq 0x24940
movsd 0x31121(%rip), %xmm1 # 0x79038
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movaps 0x2f1b4(%rip), %xmm0 # 0x770e0
pand ... | /rafat[P]ctsa/src/boxcox.c |
USPE | void USPE(double *inp,int N,int p, int q, double *phi,double *theta,double *thetac,double *var) {
int K,i,j,l,t,temp,it1;
double wmean,tempd,epsilon;
double *b,*c,*A,*c2,*x,*f,*tau,*T,*h;
int *ipiv,*ipiv2;
K = p + q + 1;
c = (double *) malloc(sizeof(double) * K);
A = (double *) malloc(sizeof(double) * p * p);
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(... | /rafat[P]ctsa/src/boxjenkins.c |
USPE_seasonal | void USPE_seasonal(double *inp,int N,int s,int p, int q, double *phi,double *theta) {
int K,i,j,l,t,temp,it1;
double tempd,epsilon;
double *b,*c,*A,*c2,*x,*f,*tau,*T,*h,*cv;
int *ipiv,*ipiv2;
K = (p + q + 1) * s;
cv = (double *) malloc(sizeof(double) * K);
c = (double *) malloc(sizeof(double) * (p+q+1));
A = ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addl $0x1, %eax
imull -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0x... | /rafat[P]ctsa/src/boxjenkins.c |
avalues | void avalues(double *w,int N,int p, int q, double *phi,double *theta,int s,int ps,int qs,
double *phis, double *thetas,int tval,double *a) {
int k,i,t,t2,newl,iter;
double temp;
double *e,*w2,*alpha,*alpha2;
e = (double*) malloc(sizeof(double) * N);
w2 = (double*) malloc(sizeof(double) * tval);
if (p > q) {... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x40(%rbp), %rax
movl 0x38(%rbp), %eax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, ... | /rafat[P]ctsa/src/boxjenkins.c |
nlalsm | int nlalsm(double *vec,int N,int p,int delta, int q, double *phi,double *theta,
int M,double *thetac,double *var,double eps,double *varcovar,double *residuals) {
int retval,i,j,l,k,t,t2,it,Norig,qd,itmax;
double lam,vmul,e1,di,eps2,stepsize,temp,tau,hmax,suminc,sumb;
double *inp,*b,*at,*at0,*x,*phi0,*theta0,*orig,... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq ... | /rafat[P]ctsa/src/boxjenkins.c |
sosqm | static double sosqm(double *vec, int N) {
double sos;
int i;
sos = 0.0;
for (i = 0; i < N;++i) {
sos += (vec[i] * vec[i]);
}
return sos;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4bdd9
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movs... | /rafat[P]ctsa/src/boxjenkins.c |
stopcheck2 | int stopcheck2(double fx,int N,double *xc,double *xf,double *jac,double *dx,double fsval,double gtol,double stol) {
int rcode,i;
double num,den;
double stop0;
double *scheck;
rcode = 0;
scheck = (double*) malloc(sizeof(double) *N);
if (fabs(fx) > fabs(fsval)) {
den = fabs(fx);
} else {
den = fabs(f... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm3, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
c... | /rafat[P]ctsa/src/conjgrad.c |
cgpr_mt | int cgpr_mt(custom_function *funcpt, custom_gradient *funcgrad, double *xc, int N, double *dx,double maxstep, int MAXITER, int *niter,
double eps,double gtol,double ftol,double xtol,double *xf) {
int i, rcode, retval, k, restart,gfdcode;
int siter;
double *xi,*temp, *rk, *pk, *jac, *jacf, *apk;
double fsval,fxf,e... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movsd %xmm0, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movsd %xmm1, -0x50(%rb... | /rafat[P]ctsa/src/conjgrad.c |
factorf | int factorf(int M) {
int N;
N = M;
while (N%7 == 0){
N = N/7;
}
while (N%3 == 0){
N = N/3;
}
while (N%5 == 0){
N = N/5;
}
while (N%2 == 0){
N = N/2;
}
return N;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x7, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x506cd
movl -0x8(%rbp), %eax
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
jmp 0x506ad
jmp 0x506cf
movl -0x8(%rbp), %eax
movl $0x3, %ecx
cltd
id... | /rafat[P]ctsa/src/conv.c |
findnexte | int findnexte(int M) {
int N;
N = M;
while (factorf(N) != 1 || N%2 != 0) {
++N;
}
return N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x506a0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x9(%rbp)
jne 0x50839
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
setne %al
movb %al, -0x9... | /rafat[P]ctsa/src/conv.c |
conv_init | conv_object conv_init(int N, int L) {
conv_object obj = NULL;
int conv_len;
conv_len = N + L - 1;
obj = (conv_object) malloc (sizeof(struct conv_set));
//obj->clen = npow2(conv_len);
//obj->clen = conv_len;
obj->clen = findnexte(conv_len);
obj->ilen1 = N;
obj->ilen2 = L;
obj->fobj = fft_real_init(ob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x20, %edi
callq 0x6160
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
callq 0x50800
movl %eax, %ecx
movq -0x10(%rbp), %r... | /rafat[P]ctsa/src/conv.c |
conv_direct | void conv_direct(fft_type *inp1,int N, fft_type *inp2, int L,fft_type *oup) {
int M,k,m,i;
fft_type t1,tmin;
M = N + L -1;
i = 0;
if (N >= L) {
for (k = 0; k < L; k++) {
oup[k] = 0.0;
for (m = 0; m <= k;m++) {
oup[k]+= inp1[m] * inp2[k-m];
}
}
for (k = L; k < M; k++) {
oup[k] = 0.0;
i... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x50b61
movl $0x0, -0x30(%... | /rafat[P]ctsa/src/conv.c |
conv_fft | void conv_fft(const conv_object obj,fft_type *inp1,fft_type *inp2,fft_type *oup) {
int i,N,L1,L2,ls;
fft_type* a;
fft_type* b;
fft_data* c;
fft_data* ao;
fft_data* bo;
fft_type* co;
N = obj->clen;
L1 = obj->ilen1;
L2 = obj->ilen2;
ls = L1 + L2 - 1;
a = (fft_type*) malloc (sizeof(fft_data) * N);
b = (ff... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %e... | /rafat[P]ctsa/src/conv.c |
convolve | int convolve(const char *type, const char *method, fft_type *inp1, int N, fft_type *inp2, int L, fft_type *oup) {
/*
method - 'direct' or 'fft'
type - One of 'full', 'same' or 'valid'
inp1 - First vector of length N
inp2 - Second vector of length L
oup2 - Output vector of :
length N+L-1, if type is 'full'
len... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c... | /rafat[P]ctsa/src/conv.c |
eps | double eps(double x) {
double y,t,epsv;
int t2;
epsv = pow(2.0,-52.0);
if (x < 0.) {
x = - x;
}
if ( x > 0. && x < 1.0) {
x /= 2.;
}
t2 = (int) ( log(x) / log ((double) 2.0));
t = pow(2.0,(double) t2);
y = epsv * t;
return y;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd 0x25e0b(%rip), %xmm0 # 0x770a0
movsd 0x27e9b(%rip), %xmm1 # 0x79138
callq 0x6080
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x512d2
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx #... | /rafat[P]ctsa/src/dist.c |
gamma | double gamma(double x) {
/*
* This C program code is based on W J Cody's fortran code.
* http://www.netlib.org/specfun/gamma
*
* References:
"An Overview of Software Development for Special Functions",
W. J. Cody, Lecture Notes in Mathematics, 506,
Numerical Analysis Dundee, 1975, G. A. Watson (ed.),
S... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movsd %xmm0, -0x10(%rbp)
movsd 0x27c98(%rip), %xmm0 # 0x79160
movsd %xmm0, -0x70(%rbp)
movsd 0x27253(%rip), %xmm0 # 0x78728
movsd %xmm0, -0x78(%rbp)
movsd 0x27c76(%rip), %xmm0 # 0x79158
movsd %xmm0, -0x80(%rbp)
movsd 0x27c61(%rip), %xmm0 ... | /rafat[P]ctsa/src/dist.c |
pgamma | double pgamma(double x, double a) {
double oup,ct,d,s,la;
double a0,a1,b0,b1,g,g0,delta,fact;
// Negative a
if (a < 0.) {
printf("a must be non-negative");
exit(1);
}
// a -> inf
la = 2.0e20;
if (a > la) {
x = la - 1.0/3.0 + sqrt(la/a)*(x - (a-1.0/3.0));
a = la;
if ( x < 0.0) {
x = 0.0;
}
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x52297
leaq 0x2724a(%rip), %rdi # 0x794d0
movb $0x0, %al
callq 0x60a0
movl $0x1, %edi
callq 0x61e0
movsd 0x26ef9(%rip), %xmm0 # 0x79198
movsd %xmm0, -0x38(%rbp)
movsd -0... | /rafat[P]ctsa/src/dist.c |
ibeta_appx | double ibeta_appx(double x, double a , double b) {
double oup,abx,c2,w1,w2,num,den;
/*
* Method 2. uses approximation and is based on equations 26.5.20
* (pgamma/qgamma) and 26.5.21 (erf)
*/
if (x < 0. || x > 1.) {
printf("x only accepts real values between 0.0 and 1.0");
exit(1);
}
if (a < 0. || b... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
ja 0x52b24
movsd -0x8(%rbp), %xmm0
movsd 0x2455a(%rip), %xmm1 # 0x77078
ucomisd %xmm1, %xmm0
jbe 0x52b3c
leaq 0x269bc(%rip), %rdi # 0x794e7
movb $0x0,... | /rafat[P]ctsa/src/dist.c |
betapdf | double betapdf(double x, double a , double b) {
double oup,la,lb;
/*
* The pdf of Beta distribution function is given by
* x^(a-1) * (1-x)^(b-1) / B(a,b)
*
* or
*
* exp((a-1)*log(x) + (b-1)*log(1-x) - beta_log(a,b))
*
* Ref 26.1.33 Abramowitz and Stegun
*/
if (x < 0. || x > 1.) {
printf("x... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
ja 0x531b4
movsd -0x8(%rbp), %xmm0
movsd 0x23eca(%rip), %xmm1 # 0x77078
ucomisd %xmm1, %xmm0
jbe 0x531cc
leaq 0x2632c(%rip), %rdi # 0x794e7
movb $0x0,... | /rafat[P]ctsa/src/dist.c |
betacdf | double betacdf(double x, double a , double b) {
double oup;
oup = ibeta(x,a,b);
// Since ibeta's method 2 uses approximation it is possible that
// the cdf function thus calculated may slightly overshoot 1.0 probability
// value so we check for any discrepancies and correct them.
if (oup > 1.0) {
oup = 1.0;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
callq 0x52d80
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x23d2b(%rip), %xmm1 # 0x77078
ucomisd %xmm1, %xmm0
jbe... | /rafat[P]ctsa/src/dist.c |
erfc1__ | double erfc1__(int ind, double x)
{
/* ----------------------------------------------------------------------- */
/* EVALUATION OF THE COMPLEMENTARY ERROR FUNCTION */
/* ERFC1(IND,X) = ERFC(X) IF IND = 0 */
/* ERFC1(IND,X) = EXP(X*X)*ERFC(X) OTHERWISE */
/* ----------------------... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd 0x25175(%rip), %xmm0 # 0x795c0
movsd %xmm0, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x60b0
movsd 0x25150(%rip), %xmm0 # 0x795b8
movsd %xmm0, -0x50(%rbp)
movs... | /rafat[P]ctsa/src/erfunc.c |
exparg | static double exparg(int l)
{
/* -------------------------------------------------------------------- */
/* IF L = 0 THEN EXPARG(L) = THE LARGEST POSITIVE W FOR WHICH
* EXP(W) CAN BE COMPUTED. ==> exparg(0) = 709.7827 nowadays. */
/* IF L IS NONZERO THEN EXPARG(L) = THE LARGEST NEGATIVE W FOR
* ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movsd 0x249f1(%rip), %xmm0 # 0x795e0
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %edx
movl $0xfffffc02, %eax # imm = 0xFFFFFC02
movl $0x400, %ecx # imm = 0x400
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -... | /rafat[P]ctsa/src/erfunc.c |
erfinv | double erfinv(double x) {
double a,t,oup,num,den,xinf,sign,temp,pi;
/*
* This implementation is based on
* J. M. Blair, C. A. Edwards, and J. H. Johnson, "Rational
Chebyshev Approximations for the Inverse of the Error Function",
Mathematics of Computation, 30 (1976) 827-830
*
* Tables from www.jstor.org's ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x54ccd
movsd 0x223b2(%rip), %xmm0 # 0x77078
movsd %xmm0, -0x40(%rbp)
jmp 0x54cda
movsd 0x223f3(%rip), %xmm0 # 0x770c8
movsd %xmm0, -0x40(%rbp)
movsd -0... | /rafat[P]ctsa/src/erfunc.c |
erfcinv | double erfcinv(double x) {
double oup,xinf,pi,t;
/*
* This implementation is based on
* J. M. Blair, C. A. Edwards, and J. H. Johnson, "Rational
Chebyshev Approximations for the Inverse of the Error Function",
Mathematics of Computation, 30 (1976) 827-830
*
* Tables from www.jstor.org's copy of the paper... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movsd %xmm0, -0x8(%rbp)
movsd 0x23d58(%rip), %xmm0 # 0x79150
movsd %xmm0, -0x18(%rbp)
movsd 0x23323(%rip), %xmm0 # 0x78728
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x21c89(%rip), %xmm1 # 0x770a0
ucomisd %xmm1, %xmm0
ja 0x55427
xorps %xmm0, %xmm0
ucomisd... | /rafat[P]ctsa/src/erfunc.c |
lls_normal | int lls_normal(double *A,double *b,int M,int N,double *x) {
int retcode,sc,i,j,c1,l;
double sum;
double *AT,*d,*C,*y,*CT;
// M - data points
// N - Number of parameters
// A - MXN; b size - M vector; AT - NXM
AT = (double*) malloc(sizeof(double) * M * N);
d = (double*) malloc(sizeof(double) * N);
C = (double*... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
movslq -0x20(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x50(%rbp)
movslq -0x20(%rbp), %rdi
shlq $0x3, %rdi
ca... | /rafat[P]ctsa/src/lls.c |
lls_qr | int lls_qr(double *Ai,double *bi,int M,int N,double *xo) {
int ret;
if (M >= N) {
ret = lls_qr_determined(Ai,bi,M,N,xo);
} else {
ret = lls_qr_undetermined(Ai,bi,M,N,xo);
}
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x55aee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp... | /rafat[P]ctsa/src/lls.c |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != NULL)... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x64025
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x63ee0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x64003
movq -0x20(%rbp), %rd... | /dcodeIO[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x1b0(%rax)
jne 0x650a1
movq -0x10(%rbp), %rdi
movb $0x1, 0x1b0(%rdi)
callq 0x72170
movq -0x10(%rbp), %rdi
callq 0x64d20
movq -0x10(%rbp), %rdi
callq 0x5d090
movq -0x10(%rbp), %rdi
callq 0x64d60
mo... | /dcodeIO[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&) | static std::string PrintTestPartResultToString(
const TestPartResult& test_part_result) {
return (Message()
<< internal::FormatFileLocation(test_part_result.file_name(),
test_part_result.line_number())
<< " " << TestPartResultTypeToString(test_part_res... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x58020
movq -0x10(%rbp), %rdi
callq 0x71190
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x711e0
movq -0x70(%rbp), %rsi
movl %eax, %... | /dcodeIO[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [34]>(char const (&) [34]) | 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 0x6d770
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4c5a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/third_party/gtest/googletest/include/gtest/gtest-message.h |
calcErrAlgebraicRnPFocalRadialSingleLin(Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, double, double, double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, int) | double calcErrAlgebraicRnPFocalRadialSingleLin(Eigen::Vector3d vr, Eigen::Vector3d Cr, Eigen::Vector3d wr, Eigen::Vector3d tr, double f, double rd, double r0, Eigen::MatrixXd X, Eigen::MatrixXd u, int direction){
double err = 0;
for (int i = 0; i < X.cols(); i++)
{
Eigen::Vector3d uh;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %xmm2, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movslq 0x4e0(%rsp), %rax
movq %rax, 0x38(%rsp)
movsd 0x3fe6e(%... | /CenekAlbl[P]RnP/c++/rnp.cpp |
AllUpper(char*) | char* AllUpper(char* arr)
{
auto len = strlen(arr);
char* res = new char[len + 1];
for(auto i = 0; i < len; i++)
{
if(arr[i] == '\0')
break;
res[i] = toupper(arr[i]);
}
res[len] = 0;
return res;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb52b0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0xb5320
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0xb5a63
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
c... | /rezalas[P]riftshadow/tests/magic_tests.c |
spdlog::logger::sink_it_(spdlog::details::log_msg const&) | SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {
for (auto &sink : sinks_) {
if (sink->should_log(msg.level)) {
SPDLOG_TRY { sink->log(msg); }
SPDLOG_LOGGER_CATCH(msg.source)
}
} | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x28, %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
callq 0xbaed0
movq %rax, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
callq 0xbaf00
movq %rax, 0xe8(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0xe8... | /rezalas[P]riftshadow/code/include/spdlog/logger-inl.h |
spdlog::details::backtracer::~backtracer() | class SPDLOG_API backtracer {
mutable std::mutex mutex_;
std::atomic<bool> enabled_{false};
circular_q<log_msg_buffer> messages_;
public:
backtracer() = default;
backtracer(const backtracer &other);
backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
backtracer &operator=(backtracer other);
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0xba920
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /rezalas[P]riftshadow/code/include/spdlog/details/backtracer.h |
spdlog::details::log_msg_buffer::~log_msg_buffer() | class SPDLOG_API log_msg_buffer : public log_msg {
memory_buf_t buffer;
void update_string_views();
public:
log_msg_buffer() = default;
explicit log_msg_buffer(const log_msg &orig_msg);
log_msg_buffer(const log_msg_buffer &other);
log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
log_... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0xbaad0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /rezalas[P]riftshadow/code/include/spdlog/details/log_msg_buffer.h |
spdlog::sinks::sink::should_log(spdlog::level::level_enum) const | SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const {
return msg_level >= level_.load(std::memory_order_relaxed);
} | subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rsp)
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0xbb3c0
movl %eax, ... | /rezalas[P]riftshadow/code/include/spdlog/sinks/sink-inl.h |
spdlog::details::os::localtime(long const&) | SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
#ifdef _WIN32
std::tm tm;
::localtime_s(&tm, &time_tt);
#else
std::tm tm;
::localtime_r(&time_tt, &tm);
#endif
return tm;
} | subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb5160
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /rezalas[P]riftshadow/code/include/spdlog/details/os-inl.h |
fmt::v9::detail::format_decimal_result<char*> fmt::v9::detail::format_decimal<char, unsigned long>(char*, unsigned long, int) | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for... | subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0xbe530
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jl 0xbe570
jmp 0xbe588
leaq 0x52399(%rip), %rdi # 0x110910
movl $0x4c0, %esi # imm = 0x4... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
int fmt::v9::detail::count_digits_fallback<unsigned __int128>(unsigned __int128) | FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
int count = 1;
for (;;) {
// Integer division is slow so do it for a group of four digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < ... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
xorl %eax, %eax
movl $0x9, %edx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0xbeff2
jmp 0xbefe5
movl 0xc(%rsp), %ea... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_int_noinline<char, fmt::v9::appender, unsigned int>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned int>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref) | FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char>& specs,
locale_ref loc) -> OutputIt {
return write_int(out, arg, specs, loc);
} | subq $0x368, %rsp # imm = 0x368
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rs... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::write_int_arg<std::conditional<num_bits<int>() <= 32 && !0, unsigned int, std::conditional<num_bits<int>() <= 64, unsigned long, unsigned __int128>::type>::type> fmt::v9::detail::make_write_int_arg<int>(int, fmt::v9::sign::type) | FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign)
-> write_int_arg<uint32_or_64_or_128_t<T>> {
auto prefix = 0u;
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
if (is_negative(value)) {
prefix = 0x01000000 | '-';
abs_value = 0 - abs_value;
} else {
constexpr const unsig... | subq $0x28, %rsp
movb %sil, %al
movl %edi, 0x1c(%rsp)
movb %al, 0x1b(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %edi
callq 0xbd8d0
testb $0x1, %al
jne 0xc032e
jmp 0xc0342
movl $0x100002d, 0x14(%rsp) # imm = 0x100002D
xorl %eax, %eax
subl 0x10(%rsp), %eax
movl %eax, 0x10(%r... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::thousands_sep_result<char> fmt::v9::detail::thousands_sep_impl<char>(fmt::v9::detail::locale_ref) | FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
auto grouping = facet.grouping();
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
} | subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x78(%rsp), %rsi
callq 0xc0960
movq 0x20(%rsp), %rdi
callq 0xb5440
movq %rax, 0x28(%rsp)
jmp 0xc0886
leaq 0x68(%rsp), %rdi
callq 0xb55c0
movq 0x28(%rs... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::det... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movl (%rax), %edi
callq 0xc09b0
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpq 0x90(%rsp), %rax
jbe 0xcadac
movl 0x84(%rsp), %eax
subq 0x90(%rsp), %rax
movq %rax, 0x10(%r... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
bool fmt::v9::detail::basic_fp<unsigned __int128>::assign<float, 0>(float) | FMT_CONSTEXPR auto assign(Float n) -> bool {
static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
// Assume Float is in the format [sign][exponent][significand].
using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
const auto num_float_significand_bits =
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x17, 0x28(%rsp)
movl $0x800000, 0x24(%rsp) # imm = 0x800000
movl $0x7fffff, 0x20(%rsp) # imm = 0x7FFFFF
leaq 0x2c(%rsp), %rdi
callq 0xc4230
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rsp)
movl... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
woff2::(anonymous namespace)::WriteLong(std::vector<unsigned char, std::allocator<unsigned char>>*, int) | void WriteLong(std::vector<uint8_t>* out, int value) {
out->push_back((value >> 24) & 255);
out->push_back((value >> 16) & 255);
out->push_back((value >> 8) & 255);
out->push_back(value & 255);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
shrl $0x18, %eax
movb %al, 0x7(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa9bd
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0xa9ca
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x5180
movl %ebp, %eax
shrl $0x10, %eax
movb %al, 0x6(%rsp)
mov... | /jlfwong[P]woff2-to-ttf/src/transform.cc |
nn_backtrace_print | void nn_backtrace_print (void)
{
void *frames[50];
int size;
size = backtrace (frames, sizeof (frames) / sizeof (frames[0]));
if (size > 1) {
/* Don't include the frame nn_backtrace_print itself. */
backtrace_symbols_fd (&frames[1], size-1, fileno (stderr));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
leaq -0x190(%rbp), %rdi
movl $0x32, %esi
callq 0x1050
movl %eax, -0x194(%rbp)
cmpl $0x1, -0x194(%rbp)
jle 0x132f
leaq -0x190(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x1a0(%rbp)
movl -0x194(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x198(%rbp)
movq 0x2c... | /nanomsg[P]nanomsg/tests/../src/utils/err.c |
nn_err_strerror | const char *nn_err_strerror (int errnum)
{
switch (errnum) {
#if defined NN_HAVE_WINDOWS
case ENOTSUP:
return "Not supported";
case EPROTONOSUPPORT:
return "Protocol not supported";
case ENOBUFS:
return "No buffer space available";
case ENETDOWN:
return "Network is do... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x9523dfd, %eax # imm = 0x9523DFD
je 0x1386
jmp 0x137a
movl -0x10(%rbp), %eax
subl $0x9523dfe, %eax # imm = 0x9523DFE
je 0x1393
jmp 0x13a0
leaq 0xc77(%rip), %rax # 0x2004
movq %rax, -... | /nanomsg[P]nanomsg/tests/../src/utils/err.c |
nn_sleep | void nn_sleep (int milliseconds)
{
int rc;
struct timespec ts;
ts.tv_sec = milliseconds / 1000;
ts.tv_nsec = milliseconds % 1000 * 1000000;
rc = nanosleep (&ts, NULL);
errno_assert (rc == 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax # imm = 0xF4240
cltq
movq %rax, -0... | /nanomsg[P]nanomsg/tests/../src/utils/sleep.c |
main | int main ()
{
#ifndef NN_HAVE_WSL
int sb;
int i;
int j;
struct nn_thread threads [THREAD_COUNT];
/* Stress the shutdown algorithm. */
#if defined(SIGPIPE) && defined(SIG_IGN)
signal (SIGPIPE, SIG_IGN);
#endif
sb = test_socket (AF_SP, NN_PUB);
test_bind (sb, SOCKET_ADDRESS);
for (j... | pushq %rbp
movq %rsp, %rbp
subq $0x970, %rsp # imm = 0x970
movl $0x0, -0x4(%rbp)
movl $0xd, %edi
movl $0x1, %esi
callq 0x1120
leaq 0x91e(%rip), %rdi # 0x2116
movl $0x5d, %esi
movl $0x1, %edx
movl $0x20, %ecx
callq 0x19e0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
leaq 0x8fd(%rip), %rdi # 0x2116
... | /nanomsg[P]nanomsg/tests/ipc_shutdown.c |
test_socket_impl | static int NN_UNUSED test_socket_impl (char *file, int line, int family,
int protocol)
{
int sock;
sock = nn_socket (family, protocol);
if (sock == -1) {
fprintf (stderr, "Failed create socket: %s [%d] (%s:%d)\n",
nn_err_strerror (errno),
(int) errno, file, line);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x10b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x1a51
movq 0x25e0(%rip), %rax # 0x3ff0
movq (%rax), %rax
movq %rax, -0... | /nanomsg[P]nanomsg/tests/testutil.h |
test_bind_impl | static int NN_UNUSED test_bind_impl (char *file, int line,
int sock, char *address)
{
int rc;
rc = nn_bind (sock, address);
if(rc < 0) {
fprintf (stderr, "Failed bind to \"%s\": %s [%d] (%s:%d)\n",
address,
nn_err_strerror (errno),
(int) errno, file, line);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1060
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1ae2
movq 0x255e(%rip), %rax # 0x3ff0
movq (%rax), %rax
movq %rax, -0x... | /nanomsg[P]nanomsg/tests/testutil.h |
routine | static void routine (NN_UNUSED void *arg)
{
int s;
s = nn_socket (AF_SP, NN_SUB);
if (s < 0 && nn_errno () == EMFILE)
return;
errno_assert (s >= 0);
test_connect (s, SOCKET_ADDRESS);
test_close (s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x21, %esi
callq 0x10b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1b23
callq 0x1190
cmpl $0x18, %eax
jne 0x1b23
jmp 0x1bcd
jmp 0x1b25
cmpl $0x0, -0xc(%rbp)
setge %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq ... | /nanomsg[P]nanomsg/tests/ipc_shutdown.c |
routine2 | static void routine2 (NN_UNUSED void *arg)
{
int s;
int i;
s = test_socket (AF_SP, NN_PULL);
for (i = 0; i < 10; ++i) {
test_connect (s, SOCKET_ADDRESS);
}
for (i = 0; i < MESSAGES_PER_THREAD; ++i) {
test_recv (s, "hello");
}
test_close (s);
active --;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x493(%rip), %rdi # 0x2116
movl $0x3e, %esi
movl $0x1, %edx
movl $0x51, %ecx
callq 0x19e0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x1ccd
movl -0xc(%rbp), %edx
leaq 0x465(%rip), %rdi # 0x2116
movl $0x41, %e... | /nanomsg[P]nanomsg/tests/ipc_shutdown.c |
Curl_altsvc_init | struct altsvcinfo *Curl_altsvc_init(void)
{
struct altsvcinfo *asi = calloc(1, sizeof(struct altsvcinfo));
if(!asi)
return NULL;
Curl_llist_init(&asi->list, NULL);
/* set default behavior */
asi->flags = CURLALTSVC_H1
#ifdef USE_HTTP2
| CURLALTSVC_H2
#endif
#ifdef USE_HTTP3
| CURLALTSVC_H3
#endif... | pushq %rbx
leaq 0x8483d(%rip), %rax # 0x95080
movl $0x1, %edi
movl $0x30, %esi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x1086d
movq %rbx, %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x3c9fc
movq $0x8, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
| /Unity-Technologies[P]curl/lib/altsvc.c |
Curl_altsvc_parse | CURLcode Curl_altsvc_parse(struct Curl_easy *data,
struct altsvcinfo *asi, const char *value,
enum alpnid srcalpnid, const char *srchost,
unsigned short srcport)
{
const char *p = value;
size_t len;
char namebuf[MAX_ALTSVC_HOSTLEN] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movl %r9d, %r15d
movq %r8, %r12
movl %ecx, 0xc(%rsp)
movq %rdx, %rbp
movq %rsi, 0x40(%rsp)
movq %rdi, %rbx
leaq 0x80(%rsp), %rdi
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0xf620
movw $0x0,... | /Unity-Technologies[P]curl/lib/altsvc.c |
cf_hc_query | static CURLcode cf_hc_query(struct Curl_cfilter *cf,
struct Curl_easy *data,
int query, int *pres1, void *pres2)
{
struct cf_hc_ctx *ctx = cf->ctx;
if(!cf->connected) {
switch(query) {
case CF_QUERY_TIMER_CONNECT: {
struct curltime *when = pres2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
testb $0x1, 0x24(%rdi)
jne 0x14ed5
movq 0x10(%r12), %r13
cmpl $0x7, %ebp
je 0x14e94
cmpl $0x5, %ebp
je 0x14e7a
cmpl $0x4, %ebp
jne 0x14ed5
movq %r13, %rdi
movq %r14... | /Unity-Technologies[P]curl/lib/cf-https-connect.c |
Curl_conn_data_pending | bool Curl_conn_data_pending(struct Curl_easy *data, int sockindex)
{
struct Curl_cfilter *cf;
(void)data;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
cf = data->conn->cfilter[sockindex];
while(cf && !cf->connected) {
cf = cf->next;
}
if(cf) {
return cf->cft->has_data_pending(cf, data);
}
r... | movq %rdi, %rax
movq 0x18(%rdi), %rcx
movslq %esi, %rdx
movq 0x260(%rcx,%rdx,8), %rdi
testq %rdi, %rdi
je 0x183b4
testb $0x1, 0x24(%rdi)
jne 0x183b7
movq 0x8(%rdi), %rdi
jmp 0x183a3
xorl %eax, %eax
retq
movq (%rdi), %rcx
movq 0x40(%rcx), %rcx
movq %rax, %rsi
jmpq *%rcx
| /Unity-Technologies[P]curl/lib/cfilters.c |
Curl_cookie_list | struct curl_slist *Curl_cookie_list(struct Curl_easy *data)
{
struct curl_slist *list;
Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
list = cookie_list(data);
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
return list;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
movl $0x2, %edx
callq 0x52b97
movq 0xaa8(%rbx), %rax
testq %rax, %rax
je 0x1f110
cmpl $0x0, 0x200(%rax)
je 0x1f110
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0xaa8(%rbx), %rax
movq (%rax,%rbp,8), %r12
testq %r12, %r... | /Unity-Technologies[P]curl/lib/cookie.c |
Curl_str2addr | struct Curl_addrinfo *Curl_str2addr(char *address, int port)
{
struct in_addr in;
if(Curl_inet_pton(AF_INET, address, &in) > 0)
/* This is a dotted IP address 123.123.123.123-style */
return Curl_ip2addr(AF_INET, &in, address, port);
#ifdef USE_IPV6
{
struct in6_addr in6;
if(Curl_inet_pton(AF_INET... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
movl $0x2, %edi
movq %r14, %rsi
callq 0x105c0
testl %eax, %eax
jle 0x1f916
leaq 0x4(%rsp), %rsi
movl $0x2, %edi
jmp 0x1f936
leaq 0x8(%rsp), %rdx
movl $0xa, %edi
movq %r14, %rsi
callq 0x105c0
testl %eax, %eax
jle 0x1f948
leaq 0x8... | /Unity-Technologies[P]curl/lib/curl_addrinfo.c |
Curl_memrchr | void *
Curl_memrchr(const void *s, int c, size_t n)
{
if(n > 0) {
const unsigned char *p = s;
const unsigned char *q = s;
p += n - 1;
while(p >= q) {
if(*p == (unsigned char)c)
return (void *)p;
p--;
}
}
return NULL;
} | testq %rdx, %rdx
je 0x1fb4e
leaq (%rdx,%rdi), %rcx
decq %rcx
xorl %eax, %eax
cmpq %rdi, %rcx
jb 0x1fb50
leaq -0x1(%rcx), %rdx
cmpb %sil, (%rcx)
movq %rdx, %rcx
jne 0x1fb36
incq %rdx
movq %rdx, %rax
retq
xorl %eax, %eax
retq
nopl (%rax)
| /Unity-Technologies[P]curl/lib/curl_memrchr.c |
Curl_ntlm_core_mk_lm_hash | CURLcode Curl_ntlm_core_mk_lm_hash(const char *password,
unsigned char *lmbuffer /* 21 bytes */)
{
unsigned char pw[14];
#if !defined(CURL_NTLM_NOT_SUPPORTED)
static const unsigned char magic[] = {
0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 /* i.e. KGS!@#$% */
};
#endif
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xf4b0
movq %rax, %r15
movl $0xe, %r12d
cmpq %r12, %rax
cmovaeq %r12, %r15
leaq 0x2(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x57948
leaq (%rsp,%r15), %rdi
addq $0x2, %rdi
subq %r15, %r... | /Unity-Technologies[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_ntlmv2_resp | CURLcode Curl_ntlm_core_mk_ntlmv2_resp(unsigned char *ntlmv2hash,
unsigned char *challenge_client,
struct ntlmdata *ntlm,
unsigned char **ntresp,
unsigned int *ntre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r15
xorl %edi, %edi
callq 0xfac0
movq %rax, %r14
movl 0xc(%r12), %esi
addl $0x30, %esi
leaq 0x75196(%rip), %rax # 0x95080
movl $0x1, %edi
movq %rsi, 0x1... | /Unity-Technologies[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_lmv2_resp | CURLcode Curl_ntlm_core_mk_lmv2_resp(unsigned char *ntlmv2hash,
unsigned char *challenge_client,
unsigned char *challenge_server,
unsigned char *lmresp)
{
unsigned char data[16];
unsigned char hmac_out... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq (%rdx), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %rax, 0x8(%rcx)
leaq 0x726ff(%rip), %rdi # 0x92790
movq %rsp, %r9
movl $0x10, %edx
movl $0x10, %r8d
callq 0x2f73b
testl %eax, %eax
jne 0x200b6
movap... | /Unity-Technologies[P]curl/lib/curl_ntlm_core.c |
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.