name string | code string | asm string | file string |
|---|---|---|---|
pextrd_ | void __bea_callspec__ pextrd_(PDISASM pMyDisasm)
{
if (GV.VEX.state == InUsePrefix) {
if (GV.VEX.pp == 1) {
verifyVEXvvvv(pMyDisasm);
if (GV.VEX.L != 0) GV.ERROR_OPCODE = UD_;
if
(((GV.EVEX.state != InUsePrefix) && (GV.REX.W_ == 1)) ||
((GV.EVEX.state == InUsePrefix) && (GV.EVEX.... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x935(%rax), %eax
cmpl $0x1, %eax
jne 0x52f05
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x1, %eax
jne 0x52ef7
movq -0x8(%rbp), %rdi
callq 0x5d410
movq -0x8(%rbp), %rax
movzbl 0x931(%rax), %eax
cmpl $0x0, %eax
je 0x... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
pinsrb_ | void __bea_callspec__ pinsrb_(PDISASM pMyDisasm)
{
if (GV.VEX.state == InUsePrefix) {
if (GV.VEX.pp == 1) {
if (GV.REX.W_ == 1) {
failDecode(pMyDisasm);
}
else {
#ifndef BEA_LIGHT_DISASSEMBLY
(void) strcpy (pMyDisasm->Instruction.Mnemonic, "vpinsrb");
#endif
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x935(%rax), %eax
cmpl $0x1, %eax
jne 0x54572
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x1, %eax
jne 0x54564
movq -0x8(%rbp), %rax
movzbl 0x928(%rax), %eax
cmpl $0x1, %eax
jne 0x543a2
movq -0x8(%rbp), %rdi
callq 0... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
dppd_ | void __bea_callspec__ dppd_(PDISASM pMyDisasm)
{
if (GV.EVEX.state == InUsePrefix) {
failDecode(pMyDisasm);
}
else if (GV.VEX.state == InUsePrefix) {
if (GV.VEX.pp == 1) {
#ifndef BEA_LIGHT_DISASSEMBLY
(void) strcpy (pMyDisasm->Instruction.Mnemonic, "vdppd");
#endif
ArgsVEX(pMyD... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x947(%rax), %eax
cmpl $0x1, %eax
jne 0x5671a
movq -0x8(%rbp), %rdi
callq 0x255e0
jmp 0x5682b
movq -0x8(%rbp), %rax
movzbl 0x935(%rax), %eax
cmpl $0x1, %eax
jne 0x5677f
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x1... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
vshufi32x4 | void __bea_callspec__ vshufi32x4(PDISASM pMyDisasm)
{
if (GV.EVEX.state == InUsePrefix) {
if (GV.VEX.pp == 1) {
if (GV.EVEX.W == 0) {
#ifndef BEA_LIGHT_DISASSEMBLY
(void) strcpy (pMyDisasm->Instruction.Mnemonic, "vshufi32x4");
#endif
}
else {
#ifndef BEA_LIGHT_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x947(%rax), %eax
cmpl $0x1, %eax
jne 0x56ab9
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x1, %eax
jne 0x56aae
movq -0x8(%rbp), %rax
movzbl 0x943(%rax), %eax
cmpl $0x0, %eax
jne 0x56a4e
movq -0x8(%rbp), %rdi
addq $0... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
vreducess | void __bea_callspec__ vreducess(PDISASM pMyDisasm)
{
if (GV.EVEX.state == InUsePrefix) {
if (GV.VEX.pp == 1) {
ArgsVEX(pMyDisasm);
getImmediat8(&pMyDisasm->Operand4, pMyDisasm);
if (GV.EVEX.W == 0) {
#ifndef BEA_LIGHT_DISASSEMBLY
(void) strcpy (pMyDisasm->Instruction.Mnemonic,... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x947(%rax), %eax
cmpl $0x1, %eax
jne 0x57385
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x1, %eax
jne 0x5737a
movq -0x8(%rbp), %rdi
callq 0x5d2d0
movq -0x8(%rbp), %rdi
addq $0x3ec, %rdi # imm = 0x3EC
mov... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
rorx_ | void __bea_callspec__ rorx_(PDISASM pMyDisasm)
{
if (GV.EVEX.state == InUsePrefix) {
failDecode(pMyDisasm);
}
else if (GV.VEX.state == InUsePrefix) {
if (GV.VEX.pp == 3) {
pMyDisasm->Instruction.Category = BMI2_INSTRUCTION;
#ifndef BEA_LIGHT_DISASSEMBLY
(void) strcpy (pMyDisasm->Instr... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x947(%rax), %eax
cmpl $0x1, %eax
jne 0x5814a
movq -0x8(%rbp), %rdi
callq 0x255e0
jmp 0x58232
movq -0x8(%rbp), %rax
movzbl 0x935(%rax), %eax
cmpl $0x1, %eax
jne 0x58227
movq -0x8(%rbp), %rax
movzbl 0x934(%rax), %eax
cmpl $0x3... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/instr_set/instructions_list.c |
Addr_ECX_disp32 | void __bea_callspec__ Addr_ECX_disp32(OPTYPE* pMyOperand, PDISASM pMyDisasm)
{
size_t i = 0;
long MyNumber;
if (GV.AddressSize == 16) {
MyNumber = *((Int16*) (GV.EIP_+2));
}
else{
MyNumber = *((Int32*) (GV.EIP_+2));
}
pMyOperand->Memory.Displacement = MyNumber;
if (GV.SYN... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0x8c8(%rax)
jne 0x596cb
movq -0x10(%rbp), %rax
movq 0x8a4(%rax), %rax
movswq 0x2(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x596de
movq -0x10(%rbp), %rax
movq 0x8a4(%rax), %rax... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_ModRM.c |
GvEv | void __bea_callspec__ GvEv(PDISASM pMyDisasm)
{
if (GV.OperandSize == 64) {
GV.MemDecoration = Arg2qword;
}
else if (GV.OperandSize == 32) {
GV.MemDecoration = Arg2dword;
}
else {
GV.MemDecoration = Arg2word;
}
decodeModrm(&pMyDisasm->Operand2, pMyDisasm);
decodeRegOpcode(&pMyDisasm->Operand... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x8c0(%rax)
jne 0x5a429
movq -0x8(%rbp), %rax
movl $0x68, 0x8c4(%rax)
jmp 0x5a456
movq -0x8(%rbp), %rax
cmpl $0x20, 0x8c0(%rax)
jne 0x5a446
movq -0x8(%rbp), %rax
movl $0x67, 0x8c4(%rax)
jmp 0x5a454
movq -0x8(%rbp), %rax
... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_Disasm.c |
eAX_Iv | void __bea_callspec__ eAX_Iv(PDISASM pMyDisasm)
{
UInt32 MyNumber;
pMyDisasm->Operand1.OpType = REGISTER_TYPE;pMyDisasm->Operand1.Registers.type = GENERAL_REG;
pMyDisasm->Operand1.Registers.gpr = REG0;
pMyDisasm->Operand2.OpType = CONSTANT_TYPE+ABSOLUTE_;
if (GV.OperandSize == 64) {
if (!Secur... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x20000, 0x1b8(%rax) # imm = 0x20000
movq -0x8(%rbp), %rax
movq $0x1, 0x1e8(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movq $0x8040000, 0x27c(%rax) # imm = 0x8040000
movq -0x8(%rbp), %rax
cmpl $0x... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_Disasm.c |
printDisp8 | size_t __bea_callspec__ printDisp8(OPTYPE* pMyOperand, size_t i, PDISASM pMyDisasm, long MyNumber)
{
size_t j;
long N;
if ((GV.EVEX.state == InUsePrefix) && (GV.EVEX.tupletype != 0)) {
N = getDisp8N(pMyDisasm);
if (N != -1) MyNumber = MyNumber * N;
}
if ((GV.RM_ == 4) && (GV.BASE_ == 4) && (GV.Archit... | 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 -0x18(%rbp), %rax
movzbl 0x947(%rax), %eax
cmpl $0x1, %eax
jne 0x605db
movq -0x18(%rbp), %rax
movzbl 0x949(%rax), %eax
cmpl $0x0, %eax
je 0x605db
movq -0x18(%rbp), %rdi
callq 0x606... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_ModRM.c |
interpretBase | size_t __bea_callspec__ interpretBase(OPTYPE* pMyOperand, size_t i, PDISASM pMyDisasm)
{
size_t j;
if ((GV.BASE_ == 5) && (GV.MOD_ == 0)) {
GV.DECALAGE_EIP += 4;
if (!Security(7, pMyDisasm)) return i;
j = i;
#ifndef BEA_LIGHT_DISASSEMBLY
i+= CopyFormattedNumber(pMyDisasm, (char*) pMyOperand-... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x5, 0x8dc(%rax)
jne 0x6141e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8cc(%rax)
jne 0x6141e
movq -0x20(%rbp), %rax
movl 0x8e4(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x8e4(%rax)
movq -... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_ModRM.c |
printArg | size_t __bea_callspec__ printArg(OPTYPE* pMyOperand, PDISASM pMyDisasm, size_t i)
{
size_t mnemonic = strlen((char*) &pMyOperand->OpMnemonic);
if (mnemonic != 0) {
i = printOneSpace(pMyDisasm, i);
(void) strcpy ((char*) &pMyDisasm->CompleteInstr+i, (char*) &pMyOperand->OpMnemonic);
i = strlen((char*) &p... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62f9f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x62ef0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x14... | /ChickenHook[P]ChickenHook/beaengine/beaengine-src/src/Includes/Routines_Disasm.c |
CivetServer::webSocketDataHandler(mg_connection*, int, char*, unsigned long, void*) | int
CivetServer::webSocketDataHandler(struct mg_connection *conn,
int bits,
char *data,
size_t data_len,
void *cbdata)
{
const struct mg_request_info *request_info = mg_get_request_in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0xc5eb
movq 0x80(%rax), %rsi
cmpq $0x0, 0x8(%rsi)
je 0xa637
testq %r15, %r15
je 0xa63b
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %rbx, %... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/CivetServer.cpp |
mg_get_option | CIVETWEB_API const char *
mg_get_option(const struct mg_context *ctx, const char *name)
{
int i;
if ((i = get_option_index(name)) == -1) {
return NULL;
} else if (!ctx || ctx->dd.config[i] == NULL) {
return "";
} else {
return ctx->dd.config[i];
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1efa1(%rip), %rdi # 0x2b1f0
leaq 0x2f832(%rip), %r12 # 0x3ba88
xorl %r15d, %r15d
movq %r14, %rsi
callq 0x7800
testl %eax, %eax
je 0xc27c
incq %r15
movq (%r12), %rdi
addq $0x18, %r12
cmpq $0x3a, %r15
jne 0xc259
movl $0x... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
mg_write | CIVETWEB_API int
mg_write(struct mg_connection *conn, const void *buf, size_t len)
{
time_t now;
int n, total, allowed;
if (conn == NULL) {
return 0;
}
if (len > INT_MAX) {
return -1;
}
/* Mark connection as "data sent" */
conn->request_state = 10;
#if defined(USE_HTTP2)
if (conn->protocol_type == PROTOC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd151
movq %rdx, %r14
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpq $0x7fffffff, %rdx # imm = 0x7FFFFFFF
ja 0xd183
movq %rsi, %r15
movq %rdi, %rbx
movl $0xa, 0x8(%rdi)
cmpl $0x0, 0x9a0(%rdi)
jle 0xd155
xorl %e... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
authorize | static int
authorize(struct mg_connection *conn, struct mg_file *filep, const char *realm)
{
struct read_auth_file_struct workdata;
char buf[MG_BUF_LEN];
if (!conn || !conn->dom_ctx) {
return 0;
}
memset(&workdata, 0, sizeof(workdata));
workdata.conn = conn;
if (!parse_auth_header(conn, buf, sizeof(buf), &w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x22b8, %rsp # imm = 0x22B8
cmpq $0x0, 0x8e8(%rdi)
je 0xf906
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rbx
xorl %r13d, %r13d
movl $0x298, %edx # imm = 0x298
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7340
m... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
send_file_data | static void
send_file_data(struct mg_connection *conn,
struct mg_file *filep,
int64_t offset,
int64_t len,
int no_buffering)
{
char buf[MG_BUF_LEN];
int to_read, num_read, num_written;
int64_t size;
if (!filep || !conn) {
return;
}
/* Sanity check th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp # imm = 0x2018
movq %rcx, %r14
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x10481
movq %rsi, %r15
movq (%rsi), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
cmovbq... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
mg_connect_websocket_client_extensions | mg_connection *
mg_connect_websocket_client_extensions(const char *host,
int port,
int use_ssl,
char *error_buffer,
size_t error_buffer_size,
... | xorl %eax, %eax
retq
| /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
get_system_name | static void
get_system_name(char **sysName)
{
#if defined(_WIN32)
char name[128];
DWORD dwVersion = 0;
DWORD dwMajorVersion = 0;
DWORD dwMinorVersion = 0;
DWORD dwBuild = 0;
BOOL wowRet, isWoW = FALSE;
#if defined(_MSC_VER)
#pragma warning(push)
/* GetVersion was declared deprecated */
#pragma warning(disable :... | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
leaq 0x2(%rsp), %r14
movl $0x186, %edx # imm = 0x186
movq %r14, %rdi
xorl %esi, %esi
callq 0x7340
movq %r14, %rdi
callq 0x7080
movq %r14, %rdi
callq 0x7290
movq %r14, %rdi
movq %rax, %rsi
callq 0x18b6f
movq %rax, (%rbx)
addq $0x... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
mg_start_thread_with_id | static int
mg_start_thread_with_id(mg_thread_func_t func,
void *param,
pthread_t *threadidptr)
{
pthread_t thread_id;
pthread_attr_t attr;
int result;
(void)pthread_attr_init(&attr);
#if defined(__ZEPHYR__)
pthread_attr_setstack(&attr,
&civet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x76e0
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x7aa0
movl %eax, %ebp
movq %r12, %rdi
callq 0x7a00
testl %ebp, %ebp
setne %al
t... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
mg_get_system_info | CIVETWEB_API int
mg_get_system_info(char *buffer, int buflen)
{
char *end, *append_eoobj = NULL, block[256];
size_t system_info_length = 0;
#if defined(_WIN32)
static const char eol[] = "\r\n", eoobj[] = "\r\n}\r\n";
#else
static const char eol[] = "\n", eoobj[] = "\n}\n";
#endif
if ((buffer == NULL) || (buflen ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
je 0x185c1
xorl %ecx, %ecx
movq %rbx, %rax
jmp 0x185cf
movb $0x0, (%rbx)
movl %esi, %eax
addq %rbx, %rax
cmp... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
next_option | static const char *
next_option(const char *list, struct vec *val, struct vec *eq_val)
{
int end;
reparse:
if (val == NULL || list == NULL || *list == '\0') {
/* End of the list */
return NULL;
}
/* Skip over leading LWS */
while (*list == ' ' || *list == '\t')
list++;
val->ptr = list;
if ((list = strch... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x18de0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x18de0
cmpb $0x0, (%rbx)
je 0x18de0
movq %rbx, %r12
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0x18d1b
cmpl $0x9, %eax
jne 0x18d23
incq %r12
incq %rbx
jmp 0x18d0c
movq %r1... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
send_ssi_file | static void
send_ssi_file(struct mg_connection *conn,
const char *path,
struct mg_file *filep,
int include_level)
{
char buf[MG_BUF_LEN];
int ch, len, in_tag, in_ssi_tag;
if (include_level > 10) {
mg_cry_internal(conn, "SSI #include level is too deep (%s)", path);
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4268, %rsp # imm = 0x4268
movq %rsi, %r9
movq %rdi, %rbx
cmpl $0xa, %ecx
jle 0x1912a
leaq 0x13786(%rip), %r8 # 0x2c893
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
addq $0x4268, %rsp # imm = 0x4268
popq %rbx
popq %r12
... | /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
mg_set_thread_name | static void
mg_set_thread_name(const char *name)
{
char threadName[16 + 1]; /* 16 = Max. thread length in Linux/OSX/.. */
mg_snprintf(
NULL, NULL, threadName, sizeof(threadName), "civetweb-%s", name);
#if defined(_WIN32)
#if defined(_MSC_VER)
/* Windows and Visual Studio Compiler */
__try {
THREADNAME_INFO... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %r9
leaq 0x1274a(%rip), %r8 # 0x2db43
movq %rsp, %rbx
movl $0x11, %ecx
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xde02
callq 0x74f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7680
addq $0x20, %rsp
popq %rbx
retq
| /jupp0r[P]prometheus-cpp/3rdparty/civetweb/src/civetweb.c |
prometheus::BuildHistogram() | detail::Builder<Histogram> BuildHistogram() { return {}; } | movq %rdi, %rax
leaq 0x8(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, (%rdi)
leaq 0x60(%rdi), %rdx
leaq 0x40(%rdi), %rsi
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
xorl ... | /jupp0r[P]prometheus-cpp/core/src/detail/builder.cc |
prometheus::BuildSummary() | detail::Builder<Summary> BuildSummary() { return {}; } | movq %rdi, %rax
leaq 0x8(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, (%rdi)
leaq 0x60(%rdi), %rdx
leaq 0x40(%rdi), %rsi
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
xorl ... | /jupp0r[P]prometheus-cpp/core/src/detail/builder.cc |
prometheus::Family<prometheus::Counter>::CollectMetric(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::... | ClientMetric Family<T>::CollectMetric(const Labels& metric_labels,
T* metric) const {
auto collected = metric->Collect();
collected.label.reserve(constant_labels_.size() + metric_labels.size());
const auto add_label =
[&collected](const std::pair<std::string, std::strin... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x1def8
movq 0x28(%r14), %rsi
addq 0xa8(%r15), %rsi
movq %rbx, %rdi
callq 0x1f804
movq 0x98(%r15), %rdi
addq $0x88, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f891
movq 0x18(%r14), %rdi
addq $0x8, %r14
movq %r14, %... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Family<prometheus::Gauge>::Collect() const | std::vector<MetricFamily> Family<T>::Collect() const {
std::lock_guard<std::mutex> lock{mutex_};
if (metrics_.empty()) {
return {};
}
auto family = MetricFamily{};
family.name = name_;
family.help = help_;
family.type = T::metric_type;
family.metric.reserve(metrics_.size());
for (const auto& m :... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r12
movq %rdi, %r14
leaq 0xb0(%rsi), %rbx
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
jne 0x20070
cmpq $0x0, 0x20(%r12)
je 0x20044
movq %rbx, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
mova... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Family<prometheus::Histogram>::Collect() const | std::vector<MetricFamily> Family<T>::Collect() const {
std::lock_guard<std::mutex> lock{mutex_};
if (metrics_.empty()) {
return {};
}
auto family = MetricFamily{};
family.name = name_;
family.help = help_;
family.type = T::metric_type;
family.metric.reserve(metrics_.size());
for (const auto& m :... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r12
movq %rdi, %r14
leaq 0xb0(%rsi), %rbx
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
jne 0x20938
cmpq $0x0, 0x20(%r12)
je 0x2090c
movq %rbx, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
mova... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Family<prometheus::Info>::Collect() const | std::vector<MetricFamily> Family<T>::Collect() const {
std::lock_guard<std::mutex> lock{mutex_};
if (metrics_.empty()) {
return {};
}
auto family = MetricFamily{};
family.name = name_;
family.help = help_;
family.type = T::metric_type;
family.metric.reserve(metrics_.size());
for (const auto& m :... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r12
movq %rdi, %r14
leaq 0xb0(%rsi), %rbx
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
jne 0x2120a
cmpq $0x0, 0x20(%r12)
je 0x211de
movq %rbx, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
mova... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Family<prometheus::Info>::Add(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std... | T& Family<T>::Add(const Labels& labels, std::unique_ptr<T> object) {
std::lock_guard<std::mutex> lock{mutex_};
auto insert_result =
metrics_.insert(std::make_pair(labels, std::move(object)));
if (insert_result.second) {
// insertion took place, retroactively check for unlikely issues
for (auto& la... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb0(%rdi), %r12
movq %r12, %rdi
callq 0x7870
testl %eax, %eax
jne 0x21581
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r12, 0x8(%rsp)
callq 0x221e0
leaq 0x8(%r15), %rbp
movq (%rbx), %r... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Family<prometheus::Summary>::Remove(prometheus::Summary*) | void Family<T>::Remove(T* metric) {
std::lock_guard<std::mutex> lock{mutex_};
for (auto it = metrics_.begin(); it != metrics_.end(); ++it) {
if (it->second.get() == metric) {
metrics_.erase(it);
break;
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xb0(%rdi), %rbx
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
jne 0x2181d
leaq 0x8(%r14), %rdi
addq $0x18, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x21810
cmpq %r15, 0x38(%r14)
jne 0x217fa
movq %r14, %rsi
callq 0x245dc
movq %rbx, %rdi
popq %rbx
p... | /jupp0r[P]prometheus-cpp/core/src/family.cc |
prometheus::Histogram::Observe(double) | void Histogram::Observe(const double value) {
const auto bucket_index = static_cast<std::size_t>(
std::distance(bucket_boundaries_.begin(),
std::lower_bound(bucket_boundaries_.begin(),
bucket_boundaries_.end(), value)));
std::lock_guard<std::mutex> loc... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rax
subq %r12, %rax
sarq $0x3, %rax
movq %r12, %r14
testq %rax, %rax
jle 0x24df4
movq %r12, %r14
movq %rax, %rcx
shrq %rcx
ucomisd (%r14,%rcx,8), %xmm0
jbe 0x24dec
leaq (%r14,%rcx,8), %r14
addq $0x8, %r14
notq %rcx... | /jupp0r[P]prometheus-cpp/core/src/histogram.cc |
bool prometheus::Registry::NameExistsInOtherType<prometheus::Info>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool Registry::NameExistsInOtherType<Info>(const std::string& name) const {
return FamilyNameExists(name, counters_, gauges_, histograms_, summaries_);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r14
movq %rsi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %r14, %rbp
subq %r15, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x25837
incq %rbp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15,... | /jupp0r[P]prometheus-cpp/core/src/registry.cc |
bool prometheus::(anonymous namespace)::FamilyNameExists<std::vector<std::unique_ptr<prometheus::Family<prometheus::Summary>, std::default_delete<prometheus::Family<prometheus::Summary>>>, std::allocator<std::unique_ptr<prometheus::Family<prometheus::Summary>, std::default_delete<prometheus::Family<prometheus::Summary>... | bool FamilyNameExists(const std::string& name, const T& families,
Args&&... args) {
auto sameName = [&name](const typename T::value_type& entry) {
return name == entry->GetName();
};
auto exists = std::find_if(std::begin(families), std::end(families),
sameNam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r13
movq %rdi, (%rsp)
movq %r13, %rbp
subq %r14, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x266b0
incq %rbp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x26758
testb %al, %al
jne 0x... | /jupp0r[P]prometheus-cpp/core/src/registry.cc |
bool prometheus::Registry::Remove<prometheus::Histogram>(prometheus::Family<prometheus::Histogram> const&) | bool Registry::Remove(const Family<T>& family) {
std::lock_guard<std::mutex> lock{mutex_};
auto& families = GetFamilies<T>();
auto same_family = [&family](const std::unique_ptr<Family<T>>& in) {
return &family == in.get();
};
auto it = std::find_if(families.begin(), families.end(), same_family);
if (i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x88(%rdi), %rbx
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
jne 0x275ae
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %r15, %rdx
callq 0x2885d
movq %rax, %r15
movq 0x48(%r14), %r12
cmpq %r12, %rax
je 0x27594
addq $0x40, %r... | /jupp0r[P]prometheus-cpp/core/src/registry.cc |
void prometheus::(anonymous namespace)::WriteHead<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, prometheus::MetricFamily const&, prometheus::ClientMetric const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_st... | void WriteHead(std::ostream& out, const MetricFamily& family,
const ClientMetric& metric, const std::string& suffix = "",
const std::string& extraLabelName = "",
const T& extraLabelValue = T()) {
out << family.name << suffix;
if (!metric.label.empty() || !extraLabelName.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x7640
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x7640
movq (%r12), %rax
cmpq ... | /jupp0r[P]prometheus-cpp/core/src/text_serializer.cc |
prometheus::detail::TimeWindowQuantiles::insert(double) | void TimeWindowQuantiles::insert(double value) {
rotate();
for (auto& bucket : ckms_quantiles_) {
bucket.insert(value);
}
} | pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %r14
callq 0x2a7a2
movq 0x8(%r14), %rbx
movq 0x10(%r14), %r14
cmpq %r14, %rbx
je 0x2a85c
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x1e5ac
addq $0xfd0, %rbx # imm = 0xFD0
jmp 0x2a841
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /jupp0r[P]prometheus-cpp/core/src/detail/time_window_quantiles.cc |
lodepng_info_copy(LodePNGInfo*, LodePNGInfo const*) | unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
lodepng_info_cleanup(dest);
*dest = *source;
lodepng_color_mode_init(&dest->color);
CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color));
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
CERROR_TRY_RETURN(LodePNGText_copy(d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x228c6
movl $0xe8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140c0
leaq 0x10(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movabsq $0x800000006, %rax # imm = 0x800000006
movq %rax, 0x10(... | /fxia22[P]egl_example/lodepng/lodepng.cpp |
getPixelColorRGBA16(unsigned short*, unsigned short*, unsigned short*, unsigned short*, unsigned char const*, unsigned long, LodePNGColorMode const*) | static void getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a,
const unsigned char* in, size_t i, const LodePNGColorMode* mode)
{
if(mode->colortype == LCT_GREY)
{
*r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1];
if(mode->key_de... | pushq %rbx
movq 0x10(%rsp), %rax
movl (%rax), %r10d
cmpq $0x6, %r10
ja 0x232dc
leaq 0xdc9f(%rip), %r11 # 0x30e18
movslq (%r11,%r10,4), %r10
addq %r11, %r10
jmpq *%r10
movzbl (%r8,%r9,2), %r10d
shll $0x8, %r10d
movzbl 0x1(%r8,%r9,2), %r11d
orl %r10d, %r11d
movw %r11w, (%rdx)
movw %r11w, (%rsi)
movw %r11w, (%rdi)
cm... | /fxia22[P]egl_example/lodepng/lodepng.cpp |
lodepng_encode(unsigned char**, unsigned long*, unsigned char const*, unsigned int, unsigned int, LodePNGState*) | unsigned lodepng_encode(unsigned char** out, size_t* outsize,
const unsigned char* image, unsigned w, unsigned h,
LodePNGState* state)
{
LodePNGInfo info;
ucvector outv;
unsigned char* data = 0; /*uncompressed version of the IDAT chunk data*/
size_t datasize = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r13
movq %rdi, %r15
xorl %eax, %eax
movq %rax, 0x38(%rsp)
movq %rax, 0x50(%rsp)
movq %rax, (%rdi)
movq %rsi, 0x58(%rsp)
movq %rax, (%rsi)
movl %eax, 0x... | /fxia22[P]egl_example/lodepng/lodepng.cpp |
addChunk_tRNS(ucvector*, LodePNGColorMode const*) | static unsigned addChunk_tRNS(ucvector* out, const LodePNGColorMode* info)
{
unsigned error = 0;
size_t i;
ucvector tRNS;
ucvector_init(&tRNS);
if(info->colortype == LCT_PALETTE)
{
size_t amount = info->palettesize;
/*the tail of palette values that all have 255 as alpha, does not have to be encoded... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rsi), %eax
testl %eax, %eax
movq %rdi, 0x18(%rsp)
je 0x26c0a
cmpl $0x2, %eax
movq %rsi, 0x8(%rsp)
je 0x26bde
xorl %edx, %edx
movl $0x0, %r12d
cmpl $0x3, %eax
jne 0x26e2c
movq 0x10(%rsi), %r13
testq %r13, %r13
je 0x26b41
movq 0x8(%... | /fxia22[P]egl_example/lodepng/lodepng.cpp |
lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | unsigned load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
long size = lodepng_filesize(filename.c_str());
if(size < 0) return 78;
buffer.resize((size_t)size);
return size == 0 ? 0 : lodepng_buffer_file(&buffer[0], (size_t)size, filename.c_str());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1efec
testq %rax, %rax
js 0x27f6b
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2afa0
testq %r15, %r15
je 0x27f72
movq (%r14), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1f05a
movl $0x4e,... | /fxia22[P]egl_example/lodepng/lodepng.cpp |
myarima | myarima_object myarima(double *x, int N, int *order, int *seasonal, int constant, const char* ic, int trace, int approx,
double offset, double *xreg, int r, int *method) {
myarima_object fit = NULL;
int m,p,d,q,P,D,Q,s,diffs,i,j,imean,ncoeff,isum,imx,rr;
int use_season,rmethod,last_nonzero,ip,iq,ir,retval;
double... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x3... | /rafat[P]ctsa/src/ctsa.c |
search_arima | myarima_object search_arima(double *x, int N,int d, int D, int p_max, int q_max, int P_max, int Q_max, int Order_max, int stationary,int s, const char *ic,
int approximation, double *xreg, int r, double offset,int allowdrift, int allowmean,int verbose, int method) {
int idrift, imean, maxK, i, j, I, J,K;
double bes... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl 0x70(%rbp), %eax
movl 0x68(%rbp), %eax
movl 0x60(%rbp), %eax
movl 0x58(%rbp), %eax
movl 0x50(%rbp), %eax
movq 0x48(%rbp), %rax
movl 0x40(%rbp), %eax
movq 0x38(%rbp), %rax
movl 0x30(%rbp), %e... | /rafat[P]ctsa/src/ctsa.c |
ar_exec | void ar_exec(ar_object obj, double *inp) {
int p, N;
double loglik;
double *hess;
N = obj->N;
obj->p = ar_estimate(inp, N, obj->method);
//printf("\n p %d \n", obj->p);
p = obj->p;
int cssml = 0;
if (obj->method == 2) {
hess = (double*)malloc(sizeof(double)* (p + 1) * (p + 1));
obj->retval = as154(inp, o... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x10050
movl %eax, %ecx
mo... | /rafat[P]ctsa/src/ctsa.c |
ar | void ar(double *inp, int N, int p,int method,double *phi,double *var) {
/*
Method 0 : Yule Walker
Method 1 : Burg
Method 2 : MLE
*/
double wmean,loglik;
double *resid,*hess;
int cssml = 0;
if (method == 0) {
ywalg2(inp, N, p, phi,var);
}
else if (method == 1) {
burgalg(inp, N - 1, p, phi, var);
}
els... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movl $0x0, -0x6c(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x10a00
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp... | /rafat[P]ctsa/src/ctsa.c |
auto_arima_setMethod | void auto_arima_setMethod(auto_arima_object obj, int value) {
if (value == 0) {
obj->method = 0;
}
else if (value == 1) {
obj->method = 1;
}
else if (value == 2) {
obj->method = 2;
}
else {
printf("\n Acceptable Numerical Values 0 - CSS-MLE, 1 - MLE, 2 - CSS \n");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x10be2
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x10c1a
cmpl $0x1, -0xc(%rbp)
jne 0x10bf5
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x10c18
cmpl $0x2, -0xc(%rbp)
jne 0x10c08
movq -0x8(%rbp), %ra... | /rafat[P]ctsa/src/ctsa.c |
arima_setOptMethod | void arima_setOptMethod(arima_object obj, int value) {
/*
* Method 0 - Nelder-Mead
* Method 1 - Newton Line Search
* Method 2 - Newton Trust Region - Hook Step
* Method 3 - Newton Trust Region - Double Dog-Leg
* Method 4 - Conjugate Gradient
* Method 5 - BFGS
* Method 6 - Limited Memory BFGS
* Method 7 - BFGS ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x10f15
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x11038
cmpl $0x1, -0xc(%rbp)
jne 0x10f2b
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
jmp 0x11036
cmpl $0x2, -0xc(%rbp)
jne 0x10f41
movq -0x8(%rbp), %ra... | /rafat[P]ctsa/src/ctsa.c |
auto_arima_setSeasonalParameters | void auto_arima_setSeasonalParameters(auto_arima_object obj,const char *test, double alpha) {
if (!strcmp(test,"ocsb") || !strcmp(test,"seas")) {
strcpy(obj->seas,test);
} else {
printf("Only two tests are allowed - seas and ocsb \n");
exit(-1);
}
obj->alpha_seas = alpha;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x65f27(%rip), %rsi # 0x77677
callq 0x6100
cmpl $0x0, %eax
je 0x1176f
movq -0x10(%rbp), %rdi
leaq 0x659f7(%rip), %rsi # 0x7715c
callq 0x6100
cmpl $0x0, %eax
jne 0x11785
m... | /rafat[P]ctsa/src/ctsa.c |
sarima_predict | void sarima_predict(sarima_object obj, double *inp, int L, double *xpred, double *amse) {
int d, i, N, ip, iq, ir,D,P,Q,s,p,q,t,ps,qs,j;
double *coef1,*coef2,*delta, *W, *resid, *phi, *theta;
double wmean;
d = obj->d;
N = obj->N;
p = obj->p;
q = obj->q;
D = obj->D;
P = obj->P;
Q = obj->Q;
s = obj->s;
ip =... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rb... | /rafat[P]ctsa/src/ctsa.c |
sarimax_wrapper_summary | void sarimax_wrapper_summary(sarimax_wrapper_object obj) {
int i, pq,t,nd,ncxreg,mean;
pq = obj->sarimax->p + obj->sarimax->q + obj->sarimax->P + obj->sarimax->Q + obj->sarimax->M;
mean = obj->sarimax->M - obj->sarimax->r;
if (obj->sarimax->method == 0 || obj->sarimax->method == 1) {
printf("\n\nExit Status \n"... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
addl 0x18(%rcx), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
addl 0x20(%rcx), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
addl 0x28(%rcx), %eax
movq -... | /rafat[P]ctsa/src/ctsa.c |
forkal | int forkal(int ip,int iq,int id,double *phi,double*theta,double *delta,int N,double *W,double *resid,int il,double *Y,double *AMSE) {
int ifault,ir,np,k,nrbar,ird,irz;
double *A,*P,*V,*store,*xrow;
double zero, one, two,AA,del,sumlog,ssq,sigma,A1,dt,phij,phijdt,phii,AMS;
int i, j, ll, nt, nj, idk, iid,iupd,nit,ite... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(... | /rafat[P]ctsa/src/emle.c |
as154 | int as154(double *inp, int N, int optmethod, int p, int d, int q, double *phi, double *theta, double *wmean, double *var,
double *resid,double *loglik,double *hess, int cssml) {
int i,pq,retval,length,ret,rp,P,Q,ERR;
double *b,*tf,*x,*dx,*thess,*varcovar,*res;
int *ipiv;
double maxstep,sigma,coeff;
alik_object ob... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl 0x48(%rbp), %eax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x30(%rbp)
movl %e... | /rafat[P]ctsa/src/emle.c |
checkroots_cerr | static int checkroots_cerr(double *phi, int *p, double *theta, int *q, double *PHI, int *P, double *THETA, int *Q) {
int ret,out;
out = 1;
if (*p > 0) {
ret = archeck(*p,phi);
if (!ret) {
out = 10;
printf("\nnon-stationary AR part\n");
return out;
}
}
if (*q > 0) {
invertroot(*q,theta);
}
if... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
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)
movl $0x1, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x1c2c2
movq -0x18(%rbp), %r... | /rafat[P]ctsa/src/emle.c |
cssx | int cssx(double *inp, int N, double *xreg, int optmethod, int p, int d, int q, int s, int P, int D, int Q,
double *phi, double *theta, double *PHI, double *THETA, double *exog, int r, double *wmean, double *var,double *loglik,double *hess,int start,int imean) {
int i, pq, retval, length, offset,ret,nd,ncxreg,N1,rnk,... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movl 0x90(%rbp), %eax
movl 0x88(%rbp), %eax
movq 0x80(%rbp), %rax
movq 0x78(%rbp), %rax
movq 0x70(%rbp), %rax
movq 0x68(%rbp), %rax
movl 0x60(%rbp), %eax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x3... | /rafat[P]ctsa/src/emle.c |
fas154x_seas | double fas154x_seas(double *b, int pq, void *params) {
double value, ssq, sumlog, delta,temp;
int p, q, ps, qs,s,offset,naram,M;
int ip, iq, ir, i,j, np, ifault, N, iupd, nit, iter;
double *phi, *theta, *A, *P, *V,*reg;
value = ssq = sumlog = 0.0;
xlik_object obj = (xlik_object)params;
ip = obj->p + (obj->s * ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(... | /rafat[P]ctsa/src/emle.c |
css_seas | int css_seas(double *inp, int N, int optmethod, int p, int d, int q, int s, int P, int D, int Q,
double *phi, double *theta, double *PHI, double *THETA, double *wmean, double *var,double *loglik,double *hess) {
int i, pq, retval, length, offset,ret;
double *b, *tf, *x, *inp2,*dx,*thess;
int *ipiv;
double maxstep;
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x68(%rbp), %rax
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -... | /rafat[P]ctsa/src/emle.c |
fcssx | double fcssx(double *b, int pq, void *params) {
double value, ssq,temp;
int p, q, ps, qs, s, d, D, offset,jm;
int ip, iq, i, j, N,iter,ncond,M,naram;
double *phi, *theta,*reg;
value = ssq = 0.0;
xlik_css_object obj = (xlik_css_object)params;
ip = obj->p + (obj->s * obj->P);
iq = obj->q + (obj->s * obj->Q);... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movl (%rax), %eax
movq -0x98(%rbp), %rcx
movl 0xc(%r... | /rafat[P]ctsa/src/emle.c |
filter | void filter(double *sig, int len_sig, double *filt, int len_filt, double *oup) {
int N,i;
double *temp;
/*
*
* filter returns the output which is of same length as the input
* unlike conv function
*
*/
N = len_sig + len_filt - 1;
temp = (double*) malloc (sizeof(double) * N);
conv_direct(sig,len_sig,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
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)
movslq -0x2c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x38(%rbp)
mov... | /rafat[P]ctsa/src/filter.c |
mafilter | void mafilter(double *sig,int N, int window,double *oup) {
int odd,q,N2,i,j;
double sum;
double *temp;
/*
* mafilter is a moving average filter that smoothes the signal using
* a smoothing window. In this implementation, the signal is extended
* by the length of the window. Length floor(window/2) extension is... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rbp), %eax
shll %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rb... | /rafat[P]ctsa/src/filter.c |
expfilter | void expfilter(double *sig,int N, double alpha,double *oup) {
int i;
double beta;
/* alpha accepts values between 0 and 1.
* No error check is implemented presently
* so make sure that the correct value of
* alpha is entered.
*/
beta = 1.0 - alpha;
oup[0] = sig[0];
for (i = 1; i < N; ++i) {
ou... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd 0x544cc(%rip), %xmm0 # 0x77078
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x24(%rbp)
mov... | /rafat[P]ctsa/src/filter.c |
mafilter_wt | void mafilter_wt(double *sig,int N, double *weights, int window,double *oup) {
int odd,q,N2,i,j,ct;
double sum;
double *temp;
/* Accepts Normalized weights.
* If the weight is not normalized then normalize it by
* dividing all the weights by the sum of all the weights
* [1,1,1,1,1] normalizes to [1,1,1... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
shll %ecx
subl %ecx, %ea... | /rafat[P]ctsa/src/filter.c |
innalg | void innalg(double *vec, int l, int N,double *v, double *theta) {
int i,j,lag,ct,ct2,index1,index2;
double temp,temp2;
double *acov;
// IMPORTANT - The program does not store the matrix as laid out
// in Brockwell and Davis
// theta is a (N+1)X(N+1) matrix so choose the value of N accordingly. The recommended
/... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
mov... | /rafat[P]ctsa/src/initest.c |
ma_inn | void ma_inn(double *inp, int N,int q, double* theta, int lag) {
// Moving Average Parameters for a MA(q) process using Innovations
// Algorithm. lag is typically set at <= 17
int i;
double *v,*thetap;
thetap = (double*) malloc(sizeof(double) * (lag+1) * (lag+1));
v = (double*) malloc(sizeof(double) * (lag+1));
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x30... | /rafat[P]ctsa/src/initest.c |
burgalg | void burgalg(double *x, int N, int p, double *phi,double *var) {
int i, j, N1, p1;
double dk,u,temp1,temp2;
double *fk, *bk, *an;
/*
This code is the C translation of Cedrick Collomb's C++ Implemnetation of Burg's Algorithm
with some minor modifications
A tutorial on linear prediction and the Burg method.
http... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rb... | /rafat[P]ctsa/src/initest.c |
hralg | void hralg(double *x, int N, int p,int q, double *phi,double *theta, double *var) {
int m,i,t,pq,j,k;
double wmean,sos;
double *inp,*phim,*a,*z,*zt,*A,*b,*temp;
int *ipiv;
inp = (double*)malloc(sizeof(double)* N);
if (p > q) {
m = p;
}
else {
m = q;
}
if (m < 10 && N > p+q+20) {
m = 10;
}
else {
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %ea... | /rafat[P]ctsa/src/initest.c |
hrstep2 | void hrstep2(double *inp, int N, int m, int p, int q, int pq, double *a, double *sos, double *var) {
double *z, *zt, *A, *b, *temp;
int *ipiv;
int i,j,k,t;
double wmean;
z = (double*)malloc(sizeof(double)* (N - m - q) * pq);
zt = (double*)malloc(sizeof(double)* (N - m - q) * pq);
A = (double*)malloc(sizeof(doub... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
movslq... | /rafat[P]ctsa/src/initest.c |
pacf_burg | void pacf_burg(double* vec, int N, double* par, int M) {
int i;
double *temp;
double var;
temp = (double*)malloc(sizeof(double)* M);
for (i = 0; i < M; ++i) {
burgalg(vec, N-1, i + 1, temp, &var);
par[i] = temp[i];
}
free(temp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x24748
movq -0x8(%rbp), %rdi
movl -... | /rafat[P]ctsa/src/initest.c |
pacf_mle | void pacf_mle(double* vec, int N, double* par, int M) {
// Using Box-Jenkins Conditional MLE
double var, thetac, eps;
double *phi, *theta, *varcovar, *res;
int i, p, mean, k,ret;
res = (double*)malloc(sizeof(double)* N);
theta = (double*)malloc(sizeof(double)* 0);
eps = macheps();
mean = 1;
for (i = 0; i < ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x70(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x6160
movq %rax, -0x60(%rbp)
movb $... | /rafat[P]ctsa/src/initest.c |
madd | void madd(double* A, double* B, double* C,int rows,int cols) {
int N,i;
/*
* C = A + B . All matrices have identical dimensions rows X cols
*/
N = rows * cols;
#pragma omp parallel for
for (i = 0; i < N; ++i) {
C[i] = A[i] + B[i];
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x25952
movq -0x8(%rbp), %rax
movslq... | /rafat[P]ctsa/src/matrix.c |
rmult | void rmult(double* A, double* B, double* C,int m,int n, int p) {
int strA,strB,strC;
int N;
register int i;
strA = m;
strB = n;
strC = p;
N = m * p;
for(i = 0; i < N; ++i) {
C[i] = 0.;
}
recmult(A,B,C,m,n,p,strA,strB,strC);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
m... | /rafat[P]ctsa/src/matrix.c |
findrec | int findrec(int *a, int *b, int *c) {
int rec;
double da,db,dc,mul;
da = (double) *a;
db = (double) *b;
dc = (double) *c;
rec = 0;
mul = 1.;
while (da + db + dc > (double) CUTOFF) {
rec++;
mul *= 2;
da = ceil(da/2.);
db = ceil(db/2.);
dc = ceil(dc/2.);
}
*a = (int) da * mul;
*b = (int) db * mul;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x38... | /rafat[P]ctsa/src/matrix.c |
add_zero_pad | void add_zero_pad(double *X, int rows, int cols, int zrow, int zcol,double *Y) {
int r,c,i,j,u,v;
r = rows + zrow;
c = cols + zcol;
for (i = 0; i < rows;++i) {
u = i*c;
v = i * cols;
for (j = 0; j < cols;++j) {
Y[u + j] = X[v + j];
}
for (j = cols; j < c;++j) {
Y[u + j] = 0.;
}
}
for (i = ro... | pushq %rbp
movq %rsp, %rbp
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 -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp... | /rafat[P]ctsa/src/matrix.c |
madd_stride | void madd_stride(double* A, double* B, double* C,int rows,int cols,int sA,int sB,int sC) {
int i,j,u,v,w;
for (i = 0; i < rows; ++i) {
u = i * sC;
v = i * sA;
w = i * sB;
for(j = 0; j < cols;j++) {
C[j + u] = A[j + v] + B[j + w];
}
}
} | pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2640e
movl -0x28(%rbp), %eax
imull 0x... | /rafat[P]ctsa/src/matrix.c |
msub_stride | void msub_stride(double* A, double* B, double* C,int rows,int cols,int sA,int sB,int sC) {
int i,j,u,v,w;
for (i = 0; i < rows; ++i) {
u = i * sC;
v = i * sA;
w = i * sB;
for(j = 0; j < cols;j++) {
C[j + u] = A[j + v] - B[j + w];
}
}
} | pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x264be
movl -0x28(%rbp), %eax
imull 0x... | /rafat[P]ctsa/src/matrix.c |
rmsub_stride | void rmsub_stride(double* A, double* B, double* C,int rows,int cols,int p,int sA,int sB,int sC) {
int i,j,u,v,w;
if (rows + cols + p <= CUTOFF) {
for (i = 0; i < rows; ++i) {
u = i * sC;
v = i * sA;
w = i * sB;
for(j = 0; j < cols;j++) {
C[j + u] = A[j + v] - B[j + w];
}
}
} else {
rows... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl... | /rafat[P]ctsa/src/matrix.c |
smult | void smult(double* A, double* B, double* C,int m,int n, int p) {
int a,b,c,nrec;
double *X,*Y,*Z,*P;
a = m;
b = n;
c = p;
nrec = findrec(&a,&b,&c);
X = (double*) malloc(sizeof(double) * a * b);
Y = (double*) malloc(sizeof(double) * b * c);
Z = (double*) malloc(sizeof(double) * a * c);
P = (double*) malloc(siz... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %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)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
l... | /rafat[P]ctsa/src/matrix.c |
getPLU | void getPLU(double *A, int M , int N, int *ipiv,double *P, double *L, double *U) {
int i, j,k;
// Initialize all the arrays
// P - M*M
// M > N
// L - M*N , U - N*N
// M = N
// L - M*M , U M*M
// M < N
// L - M*M, U - M*N
if (P) {
for (i = 0; i < M*M; ++i) {
P[i] = 0.0;
}
for (j = 0; j < M; ++j) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27f5b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0xc(%rbp), %ecx
imull -0xc(%rbp), ... | /rafat[P]ctsa/src/matrix.c |
getPU | void getPU(double *A, int M, int N, int *ipiv, double *P,double *U) {
int i,j,K;
int *ipivt;
double *L;
ipivt = (int*)malloc(sizeof(int)*M);
for (i = 0; i < M; ++i) {
ipivt[ipiv[i]] = i;
}
if (M > N) {
K = N;
}
else {
K = M;
}
L = (double*)malloc(sizeof(double)*M*K);
if (M == N) {
if (L) {
f... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x6160
movq %rax, -0x40(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %ea... | /rafat[P]ctsa/src/matrix.c |
marsaglia_generate | double* marsaglia_generate(double *values, int N, double average, double deviation)
{
int i;
int M;
double x, y, rsq, f;
M = N + N % 2;
for (i = 0; i < N - 1; i += 2)
{
do {
x = 2.0 * rand() / (double)RAND_MAX - 1.0;
y = 2.0 * rand() / (double)RAND_MAX - 1.0;
rsq = x * x + y * y;
} while (rsq >=... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x4c(%rbp), %eax
addl %edx, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp... | /rafat[P]ctsa/src/matrix.c |
linsolve | void linsolve(double *A,int N,double *b,int *ipiv,double *x) {
int i,j,c1,l;
double *y;
double sum;
y = (double*) malloc(sizeof(double) *N);
/*
* Two step Solution L * U * x = b
* Let U*x = y
* Solve L * y = b for y (Forward Substitution
* Solve U * x = b for x (Back Substitution)
*/
for(i = 0; i < N... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x40(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x28db7
movq -0x... | /rafat[P]ctsa/src/matrix.c |
house_2 | double house_2(double*x,int N,double *v) {
double sgn,beta,sc;
double *sigma,*e;
int i;
sigma = (double*) malloc(sizeof(double) * 1);
e = (double*) malloc(sizeof(double) * N);
beta = 2.0;
sgn = 1.0;
mmult(x,x,sigma,1,N,1);
sigma[0] = sqrt(sigma[0]);
e[0] =1.;
for (i = 1; i < N;++i) {
e[i] = 0.;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x8, %edi
callq 0x6160
movq %rax, -0x38(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6160
movq %rax, -0x40(%rbp)
movsd 0x4de96(%rip), %xmm0 # 0x770a0
movsd %xmm0, -0x28(%rbp)
movsd 0x4de61(%r... | /rafat[P]ctsa/src/matrix.c |
housemat | void housemat(double *v, int N,double beta,double *mat) {
double *temp;
temp = (double*) malloc(sizeof(double) * N * N);
eye(mat,N);
mmult(v,v,temp,N,1,N);
scale(temp,N,N,beta);
msub(mat,temp,mat,N,N);
free(temp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x290b0
movq -0x... | /rafat[P]ctsa/src/matrix.c |
tred2 | static void tred2(double *a, int N, double *d, double *e) {
// Modified version of Numerical recipes tred2 alogorithm
int l, k, j, i;
double scale, hh, h, g, f;
for (i = N - 1; i > 0; --i) {
l = i - 1;
h = scale = 0.0;
if (l > 0) {
for (k = 0; k <= l; ++k) {
scale +=(double) fabs(a[i*N + k]);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x29c3d
movl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xm... | /rafat[P]ctsa/src/matrix.c |
eig22 | void eig22(double *A, int stride,double *eigre,double *eigim) {
int N;
double a11,a12,a21,a22,c,s,c2,s2,cs,t1,t,t2,at11,at12,at21,at22;
N = stride;
a11 = A[0];
a12 = A[1];
a21 = A[N];
a22 = A[N+1];
if ( (a12 + a21) == 0) {
c = 1./sqrt(2.0);
s = c;
} else {
t1 = (a11 - a22) / (a12 + a21);
t = t1 /(1... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq... | /rafat[P]ctsa/src/matrix.c |
francis_iter | int francis_iter(double *A, int N, double *H) {
int success,brkpoint;
int i,j,it,p,q,t,u;
double *temp;
success = 0;
brkpoint = 30 * N;
it = 0;
p = N - 1;
temp = (double*) malloc(sizeof(double) * N * N);
for(i = 0; i < N*N;++i) {
H[i] = A[i];
}
hessenberg(H,N);
while (p > 1 && it < brkpoint) {
wh... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
imull $0x1e, -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0... | /rafat[P]ctsa/src/matrix.c |
eig | void eig(double *A,int N,double *eigre,double *eigim) {
int i,t,u,n;
double *H;
double t1,t2,cs;
H = (double*) malloc(sizeof(double) * N * N);
n = N - 1;
francis_iter(A,N,H);
//mdisplay(H,N,N);
i = 0;
while (i < n) {
u = i * N;
t = (i+1)*N;
if (H[t+i] != 0.) {
eig2t(H+u+i,N);
i = i +2;
} else {
... | 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
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x... | /rafat[P]ctsa/src/matrix.c |
eig2t | static void eig2t(double *A, int stride) {
int N;
double a11,a12,a21,a22,c,s,c2,s2,cs,t1,t,at11,at12,at21,at22;
N = stride;
a11 = A[0];
a12 = A[1];
a21 = A[N];
a22 = A[N+1];
if ( (a12 + a21) == 0) {
c = 1./sqrt(2.0);
s = c;
} else {
t1 = (a11 - a22) / (a12 + a21);
t = t1 /(1. + sqrt(1+t1*t1));
c ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
mov... | /rafat[P]ctsa/src/matrix.c |
cholu | int cholu(double *A, int N) {
int stride,i,j,t,sc;
double *U22;
U22 = (double*) malloc(sizeof(double) * N * N);
stride = N;
sc = rcholu(A,N,stride,U22);
for(i=0; i < N;++i) {
t = i *N;
for(j=0;j < i;++j) {
A[t+j] = 0.;
}
}
free(U22);
return sc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
mov... | /rafat[P]ctsa/src/matrix.c |
bcholu | int bcholu(double *A, int N) {
int stride,i,j,t,b,sc;
double *UB,*UT;
b = (int) BLOCKSIZE;
UT = (double*) malloc(sizeof(double) * N * N);
UB = (double*) malloc(sizeof(double) * b * b);
stride = N;
sc = rbcholu(A,N,stride,UB,UT);
for(i=0; i < N;++i) {
t = i *N;
for(j=0;j < i;++j) {
A[t+j] = 0.;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x40, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x38(%rbp)
movslq -0x20(%rbp), %rdi
shlq $0x3, %rdi
movslq -0x20(%rbp), %rax
imulq %rax, %rdi
callq 0x... | /rafat[P]ctsa/src/matrix.c |
svd_sort | void svd_sort(double *U,int M,int N,double *V,double *q) {
/*
* Pavel Sakov's CSA SVD sort routine is used with some minor
* modifications. See The License below
*/
/*
* Copyright (C) 2000-2008 Pavel Sakov and CSIRO
Redistribution and use of material from the package `csa', with or without
modification, are ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movslq -0x10(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x30(%rbp)
movslq -0x10(%rbp), %rdi
shlq $0x3, %rdi
movsl... | /rafat[P]ctsa/src/matrix.c |
svd | int svd(double *A,int M,int N,double *U,double *V,double *q) {
int i,j,k,l,t,t2,ierr,cancel,iter,l1;
double eps,g,x,s,temp,f,h,c,y,z,scale;
double *e;
/*
THIS SUBROUTINE IS THE MODIFIED C TRANSLATION OF THE
EISPACK FORTRAN TRANSLATION OF THE ALGOL PROCEDURE SVD,
NUM. MATH. 14, 403-420(1970) BY GOLUB ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %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 -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2d2c1
leaq 0x4ac6d(%rip), %rdi # 0x77f0d
movb $0x0, %al
callq 0x60a0
leaq 0x4ac8d(%r... | /rafat[P]ctsa/src/matrix.c |
rank | int rank(double *A, int M,int N) {
int rnk;
double *AT;
AT = (double*) malloc(sizeof(double) * M*N);
if (M < N) {
mtranspose(A,M,N,AT);
rnk = rank_c(AT,N,M);
} else {
rnk = rank_c(A,M,N);
}
free(AT);
return rnk;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0x10(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2e93a
movq -0x8(%rbp), %rdi
movl -0xc(%r... | /rafat[P]ctsa/src/matrix.c |
cholmod | double cholmod(double *A, int N, double *L, double eps,double maxinp) {
/*
* Algorithm 5.5.2 Dennis, Schnabel, Numerical Methods for Unconstrained Optimization and
* Non-Linear Equations
*/
int i,j,k,step,step2;
double ls;
double *U22;
double maxadd,maxdiag,minl,minl2,minljj;
U22 = (double*) malloc(size... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x61f0
call... | /rafat[P]ctsa/src/newtonmin.c |
linsolve_lower | void linsolve_lower(double *L,int N,double *b,double *x) {
int i,j,c1,l;
double *y,*A;
double sum;
y = (double*) malloc(sizeof(double) *N);
A = (double*) malloc(sizeof(double) *N *N);
for(i = 0; i < N;++i) {
y[i] = 0.;
x[i] = 0.;
if ( L[i*N + i] == 0.) {
printf("The Matrix system does not have a uniq... | 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, -0x38(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
callq 0x6160
movq %rax, -0x40... | /rafat[P]ctsa/src/newtonmin.c |
hessian_fd | int hessian_fd(custom_function *funcpt,double *x,int N,double *dx,double eps,double *f) {
int i,j,retval;
double stepi,stepj,fd,stepmax;
double *xi,*xj,*xij;
retval = 0;
fd = pow((double) eps,1.0/3.0);
xi = (double*) malloc(sizeof(double) *N);
xj = (double*) malloc(sizeof(double) *N);
xij = (double*) malloc(... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x480d9(%rip), %xmm1 # 0x78080
callq 0x6080
movsd %xmm0, -0x60(%rbp)
movslq -0x1... | /rafat[P]ctsa/src/newtonmin.c |
hessian_fdg | void hessian_fdg(custom_gradient *funcgrad, double *x, int N, double *jac, double *dx, double eps2, double *H) {
int i,j,k;
fdjac(funcgrad,x,N,jac,dx,eps2,H);
for(i = 0; i < N;++i) {
k = i * N;
for(j = 0; j < N;++j) {
H[k + j] = (H[k + j] + H[j*N + i]) / 2.0;
}
}
} | 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)
movsd %xmm0, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
mov... | /rafat[P]ctsa/src/newtonmin.c |
hessian_opt | int hessian_opt(custom_function *funcpt, custom_gradient *funcgrad, double *x, int N, double *jac,
double *dx,double eps,double eps2,double *H) {
int retval;
retval = 0;
if (funcgrad == NULL) {
//printf("HESSF \n");
retval = hessian_fd(funcpt,x,N,dx,eps,H);
} else {
//printf("HESSG \n");
hessian_fdg(funcg... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30dad
movq -0x8(%... | /rafat[P]ctsa/src/newtonmin.c |
lnsrchcg | int lnsrchcg(custom_function *funcpt, custom_gradient *funcgrad, double *xi, double *jac, double *p, int N, double * dx, double maxstep,
double eps2,double stol,double *x,double *jacf) {
int retval,i,gfdcode;
double alpha,lambda,lambdamin,funcf,funci,lambdaprev,lambdatemp,funcprev;
double lambda2,lambdaprev2,ll,den... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
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)
movl %r9d, -0x34(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x48(%rb... | /rafat[P]ctsa/src/newtonmin.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.