LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: enfiskutensykkel[P]lamport/src/producer.cpp
// Function: tsdiff(timespec const&, timespec const&)
static inline uint64_t tsdiff(const timespec& minuend, const timespec& subtrahend)
{
	timespec difference;

	if ((minuend.tv_sec < subtrahend.tv_sec) || 
			((minuend.tv_sec == subtrahend.tv_sec) && (minuend.tv_nsec <= subtrahend.tv_nsec)))
	{
		difference.tv_sec = difference.tv_nsec = 0;
	}
	else
	{
		difference.tv_sec = minuend.tv_sec - subtrahend.tv_sec;
		if (minuend.tv_nsec < subtrahend.tv_nsec)
		{
			difference.tv_nsec = minuend.tv_nsec + 1000000000L - subtrahend.tv_nsec;
			--difference.tv_sec;
		}
		else
		{
			difference.tv_nsec = minuend.tv_nsec - subtrahend.tv_nsec;
		}
	}

	return difference.tv_sec * 1000000000L + difference.tv_nsec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jl 0x3b2e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x3b40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jg 0x3b40
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
jmp 0x3ba2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x3b8c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3ba0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ba2
imulq $0x3b9aca00, -0x20(%rbp), %rax # imm = 0x3B9ACA00
addq -0x18(%rbp), %rax
popq %rbp
retq
// File: enfiskutensykkel[P]lamport/src/queue.cpp
// Function: Queue::Queue(unsigned int)
Queue::Queue(uint32_t slots)
	: capacity(nearest_pow(slots - 1))
	, head(0), tail(0)
	, buffer(nullptr)
{
	buffer = new int*[capacity];
	if (buffer == nullptr)
	{
		throw std::runtime_error("failed to allocate queue buffer");
	}

	for (uint32_t i = 0; i < capacity; ++i)
	{
		buffer[i] = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x3d6a(%rip), %rcx      # 0x8d58
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x50f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl 0x8(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x50a7
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1325(%rip), %rsi      # 0x6397
callq 0x2060
jmp 0x5079
movq -0x30(%rbp), %rdi
movq 0x3f74(%rip), %rsi      # 0x8ff8
movq 0x3f3d(%rip), %rdx      # 0x8fc8
callq 0x2210
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20d0
jmp 0x50de
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x50d8
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x50ae
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb_load.c
// Function: unhex
static int unhex(unsigned char *c2)
{
	int x, c;
	x = *c2++ & 0x4f;
	if (x & 0x40)
		x -= 55;
	c = x << 4;
	x = *c2 & 0x4f;
	if (x & 0x40)
		x -= 55;
	c |= x;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
andl $0x4f, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x3814
movl -0xc(%rbp), %eax
subl $0x37, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x4f, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x383e
movl -0xc(%rbp), %eax
subl $0x37, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: StanHash[P]nesdump/nes.cc
// Function: get_mapper_info(unsigned char)
MapperInfo const* get_mapper_info(std::uint8_t mapper_id)
{
    switch (mapper_id)
    {

    case 0: return &s_mapper_nrom;
    case 1: return &s_mapper_mmc1;
    case 2: return &s_mapper_unrom;
    case 3: return &s_mapper_cnrom;
    case 4: return &s_mapper_mmc3;
    case 5: return &s_mapper_mmc5;
    case 7: return &s_mapper_aorom;
    case 9: return &s_mapper_mmc2;
    case 10: return &s_mapper_mmc4;
    case 16: return &s_mapper_bandai;

    default:
        return &s_mapper_bad;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x10, %rax
ja 0x52f5
movq -0x18(%rbp), %rax
leaq 0xf41(%rip), %rcx       # 0x61a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4a09(%rip), %rax      # 0x9c80
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a11(%rip), %rax      # 0x9c98
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a1c(%rip), %rax      # 0x9cb0
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a27(%rip), %rax      # 0x9cc8
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a32(%rip), %rax      # 0x9ce0
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a3d(%rip), %rax      # 0x9cf8
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a48(%rip), %rax      # 0x9d10
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a53(%rip), %rax      # 0x9d28
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a5e(%rip), %rax      # 0x9d40
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a69(%rip), %rax      # 0x9d58
movq %rax, -0x8(%rbp)
jmp 0x5300
leaq 0x4a74(%rip), %rax      # 0x9d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/./include/filters.hpp
// Function: Crop::SetRegion(int, int, int, int)
void           SetRegion(int Istart_, int Istop_, int Jstart_, int Jstop_)
                      {
                        Istart = Istart_;
                        Istop  = Istop_;
                        Jstart = Jstart_;
                        Jstop  = Jstop_;
                      }

// Assembly:
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 -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x40(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x44(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/image.cpp
// Function: Image::Image()
Image::Image(void)
{
	width = 0;
	height = 0;
	data = NULL;
	lastSource = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x8bad(%rip), %rcx      # 0xc820
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/image.cpp
// Function: Image::Image(int, int, Pixel*)
Image::Image(int width, int height, Pixel *data)
{
	this->width = width;
	this->height = height;
	this->data = data;
	lastSource = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
leaq 0x8b63(%rip), %rcx      # 0xc820
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/image.cpp
// Function: Image::Image(Image&)
Image::Image(Image &im)
{
	width = im.GetWidth();
	height = im.GetHeight();
	data = new Pixel[width * height];
	Pixel *originalBuffer = im.GetBuffer();
        std::memcpy(data, originalBuffer, width * height * sizeof(Pixel));
	lastSource = im.lastSource;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x8b11(%rip), %rcx      # 0xc820
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3db0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3dd0
movq -0x20(%rbp), %rcx
movl %eax, 0xc(%rcx)
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x3df0
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq 0x10(%rcx), %rdi
movq -0x18(%rbp), %rsi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
cltq
imulq $0x3, %rax, %rdx
callq 0x30d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: CodyNault[P]Image-Filter-Dataflow/src/sink.cpp
// Function: Sink::TwoInputCheck()
void Sink::TwoInputCheck()
{
    if(inputImg1 == NULL){
	char msg[1028];
        sprintf(msg, "%s: no input1!", SinkName());
        DataFlowException except(SinkName(), msg);
        throw except;
    }
    if(inputImg2 == NULL){
	char msg[1028];
        sprintf(msg, "%s: no input2!", SinkName());
        DataFlowException except(SinkName(), msg);
        throw except;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1070, %rsp           # imm = 0x1070
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1040(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4153
movq -0x1040(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq 0x4f8c(%rip), %rsi      # 0x903b
xorl %eax, %eax
leaq -0x410(%rbp), %rdi
movq %rdi, -0x1058(%rbp)
callq 0x3050
movq -0x1040(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x1058(%rbp), %rdx
movq %rax, %rsi
leaq -0x818(%rbp), %rdi
movq %rdi, -0x1050(%rbp)
callq 0x8420
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq -0x1050(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x1048(%rbp)
callq 0x4240
movq -0x1048(%rbp), %rdi
leaq 0x8769(%rip), %rsi      # 0xc888
leaq 0x16a(%rip), %rdx       # 0x4290
callq 0x31c0
jmp 0x4232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x820(%rbp)
movl %eax, -0x824(%rbp)
leaq -0x818(%rbp), %rdi
callq 0x4290
jmp 0x4226
movq -0x1040(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x421d
movq -0x1040(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq 0x4ecb(%rip), %rsi      # 0x904a
xorl %eax, %eax
leaq -0xc30(%rbp), %rdi
movq %rdi, -0x1070(%rbp)
callq 0x3050
movq -0x1040(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x1070(%rbp), %rdx
movq %rax, %rsi
leaq -0x1038(%rbp), %rdi
movq %rdi, -0x1068(%rbp)
callq 0x8420
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq -0x1068(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x1060(%rbp)
callq 0x4240
movq -0x1060(%rbp), %rdi
leaq 0x8699(%rip), %rsi      # 0xc888
leaq 0x9a(%rip), %rdx        # 0x4290
callq 0x31c0
jmp 0x4232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x820(%rbp)
movl %eax, -0x824(%rbp)
leaq -0x1038(%rbp), %rdi
callq 0x4290
jmp 0x4226
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
movq -0x820(%rbp), %rdi
callq 0x31d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/source.cpp
// Function: Source::updateSourceRefs(Source*)
void Source::updateSourceRefs(Source *ref)
{
	if(Source::sourceRefLog.count(ref) > 0){
		DataFlowException except("Source", "Circular Reference in DataFlow");
                throw except;
	}
	Source::sourceRefLog.insert(ref);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
leaq 0x8df2(%rip), %rdi      # 0xd148
leaq -0x8(%rbp), %rsi
callq 0x4490
cmpq $0x0, %rax
jbe 0x43e2
leaq 0x4d07(%rip), %rsi      # 0x9073
leaq 0x4d07(%rip), %rdx      # 0x907a
leaq -0x410(%rbp), %rdi
movq %rdi, -0x440(%rbp)
callq 0x8420
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq -0x440(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x438(%rbp)
callq 0x4240
movq -0x438(%rbp), %rdi
leaq 0x84d4(%rip), %rsi      # 0xc888
leaq -0x12b(%rip), %rdx      # 0x4290
callq 0x31c0
jmp 0x4414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x418(%rbp)
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x4290
jmp 0x4408
leaq 0x8d5f(%rip), %rdi      # 0xd148
leaq -0x8(%rbp), %rsi
callq 0x44f0
movq %rax, -0x430(%rbp)
movb %dl, -0x428(%rbp)
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
movq -0x418(%rbp), %rdi
callq 0x31d0
nopw %cs:(%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/PNMreader.cpp
// Function: PNMreader::Execute()
void PNMreader::Execute()
{
	FILE *f_in = NULL;
	char magicNum[3];
	int i = 0;
	int width = 0;
	int height = 0;
	int maxval = 0;
	unsigned char val[1];

	f_in = fopen(filename, "rb");
	if(f_in == NULL){
		fprintf(stderr, "Failure opening input file");
		exit(EXIT_FAILURE);
	}
	fscanf(f_in,"%s\n%d %d\n%d\n",magicNum,&width,&height,&maxval);

	Pixel *data = new Pixel[width * height];
	fread(data, sizeof(Pixel), width * height , f_in);
	fclose(f_in);
	outputImg.ResetSize(width,height);
	outputImg.SetBuffer(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq 0x28(%rax), %rdi
leaq 0x3636(%rip), %rsi      # 0x9099
callq 0x3150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5a95
movq 0x755e(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x3618(%rip), %rsi      # 0x909c
movb $0x0, %al
callq 0x3180
movl $0x1, %edi
callq 0x3160
movq -0x10(%rbp), %rdi
leaq -0x13(%rbp), %rdx
leaq 0x3613(%rip), %rsi      # 0x90b7
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x24(%rbp), %r9
movb $0x0, %al
callq 0x31e0
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rcx
movl $0x3, %esi
callq 0x3190
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x3e90
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x3eb0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/PNMreader.cpp
// Function: PNMreader::Update()
void PNMreader::Update(){
        char msg[128];
        sprintf(msg, "%s: about to execute", SourceName());
        Logger::LogEvent(msg);
        try{
                Execute();
        }catch(DataFlowException& except){
                sprintf(msg, "Throwing exception: (%s): %s", SourceName(), except.what());
                Logger::LogEvent(msg);
                throw except;
        }
        sprintf(msg, "%s: done executing", SourceName());
        Logger::LogEvent(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq 0x3557(%rip), %rsi      # 0x90c4
xorl %eax, %eax
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3050
movq -0xb8(%rbp), %rdi
callq 0x8470
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x5b9f
jmp 0x5c97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5cdf
movq -0x98(%rbp), %rdi
callq 0x3080
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0xc0(%rbp)
jmp 0x5c03
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rdx
movq %rax, %rcx
leaq 0x34ae(%rip), %rsi      # 0x90d9
xorl %eax, %eax
callq 0x3050
leaq -0x90(%rbp), %rdi
callq 0x8470
jmp 0x5c40
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq %rax, %rdi
movq %rdi, -0xd0(%rbp)
movq -0xa8(%rbp), %rsi
callq 0x5d00
movq -0xd0(%rbp), %rdi
leaq 0x6c1a(%rip), %rsi      # 0xc888
leaq -0x19e5(%rip), %rdx     # 0x4290
callq 0x31c0
jmp 0x5cf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0x31b0
jmp 0x5c95
jmp 0x5cdf
movq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movq -0xd8(%rbp), %rdi
movq %rax, %rdx
leaq 0x3433(%rip), %rsi      # 0x90f6
movb $0x0, %al
callq 0x3050
leaq -0x90(%rbp), %rdi
callq 0x8470
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/PNMwriter.cpp
// Function: PNMwriter::Write(char const*)
void PNMwriter::Write(const char *filename)
{
	FILE *f_out;
	f_out = fopen(filename, "w+");
	if(f_out == NULL){
		fprintf(stderr, "Failure opening output file");
		exit(EXIT_FAILURE);
	}
	fprintf( f_out, "P6\n%d %d\n255\n", inputImg1->GetWidth(), inputImg1->GetHeight());
	fwrite (inputImg1->GetBuffer() , sizeof(Pixel), inputImg1->GetHeight() * inputImg1->GetWidth() , f_out);
	fclose(f_out);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x336b(%rip), %rsi      # 0x911e
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5de5
movq 0x720e(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x334d(%rip), %rsi      # 0x9121
movb $0x0, %al
callq 0x3180
movl $0x1, %edi
callq 0x3160
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0x3db0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x34(%rbp)
movq 0x8(%rax), %rdi
callq 0x3dd0
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movl %eax, %ecx
leaq 0x3321(%rip), %rsi      # 0x913d
movb $0x0, %al
callq 0x3180
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3df0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x3dd0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x8(%rax), %rdi
callq 0x3db0
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movl -0x24(%rbp), %eax
imull %ecx, %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x3, %esi
callq 0x3200
movq -0x18(%rbp), %rdi
callq 0x3100
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Shrinker::Execute()
void Shrinker::Execute()
{
	OneInputCheck();
	Pixel *data = inputImg1->GetBuffer();
	int oldWidth = inputImg1->GetWidth();
	int newWidth = oldWidth / 2;
	int newHeight = inputImg1->GetHeight() / 2;
	Pixel *smallerData = new Pixel[ newWidth * newHeight];
	for(int i = 0; i < newHeight; i++)
	{
		for(int j = 0; j < newWidth; j++)
		{
			smallerData[i * newWidth + j] = data[2* i * oldWidth + 2 * j];
		}
	}
	outputImg.ResetSize(newWidth,newHeight);
	outputImg.SetBuffer(smallerData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x28, %rdi
callq 0x3fa0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3df0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x30(%rax), %rdi
callq 0x3db0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x30(%rax), %rdi
callq 0x3dd0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5f9e
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5f91
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %eax
shll %eax
imull -0x14(%rbp), %eax
movl -0x30(%rbp), %edx
shll %edx
addl %edx, %eax
cltq
imulq $0x3, %rax, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %edx
imull -0x18(%rbp), %edx
addl -0x30(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movw (%rcx), %dx
movw %dx, (%rax)
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5f3d
jmp 0x5f93
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5f2e
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x3e90
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x3eb0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Transpose::Execute()
void Transpose::Execute()
{
	OneInputCheck();
        int oldHeight = inputImg1->GetHeight();
        int oldWidth = inputImg1->GetWidth();
        int newHeight = oldWidth;
        int newWidth = oldHeight;
	Pixel *outBuffer = new Pixel[newHeight * newWidth];
	Pixel *inBuffer1 = inputImg1->GetBuffer();
	for (int h = 0 ; h < oldHeight ; h++){
        	for (int w = 0 ; w < oldWidth ; w++){
			outBuffer[w * oldHeight + h] = inBuffer1[h * oldWidth + w];
                }
        }
        outputImg.ResetSize(newWidth, newHeight);
        outputImg.SetBuffer(outBuffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x28, %rdi
callq 0x3fa0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3dd0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x30(%rax), %rdi
callq 0x3db0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x3df0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x74ce
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x74c1
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
imull -0x10(%rbp), %eax
addl -0x30(%rbp), %eax
cltq
imulq $0x3, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %edx
imull -0xc(%rbp), %edx
addl -0x2c(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movw (%rcx), %dx
movw %dx, (%rax)
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7473
jmp 0x74c3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7464
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3e90
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x3eb0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Invert::Execute()
void Invert::Execute()
{
        OneInputCheck();
        int height = inputImg1->GetHeight();
        int width = inputImg1->GetWidth();
        Pixel *outBuffer = new Pixel[height * width];
        Pixel *inBuffer1 = inputImg1->GetBuffer();
        for (int h = 0 ; h < height ; h++){
                for (int w = 0 ; w < width ; w++){
                        outBuffer[h * width + w].red = 255 - inBuffer1[h * width + w].red;
                        outBuffer[h * width + w].green = 255 - inBuffer1[h * width + w].green;
                        outBuffer[h * width + w].blue = 255 - inBuffer1[h * width + w].blue;
                }
        }
        outputImg.ResetSize(width, height);
        outputImg.SetBuffer(outBuffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x3fa0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3dd0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x30(%rax), %rdi
callq 0x3db0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x30(%rax), %rdi
callq 0x3df0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7683
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7673
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
movl $0xff, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %edx
imull -0x10(%rbp), %edx
addl -0x28(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %ecx
movl $0xff, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %edx
imull -0x10(%rbp), %edx
addl -0x28(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2(%rax), %ecx
movl $0xff, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %edx
imull -0x10(%rbp), %edx
addl -0x28(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x759b
jmp 0x7675
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7588
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x3e90
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x3eb0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Color::Color(int, int, int, int, int)
Color::Color(int w, int h, int r, int g, int b)
{
	red = r;
	green = g;
	blue = b;
	width = w;
	height = h;
}

// Assembly:
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 %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3ba0
movq -0x28(%rbp), %rax
leaq 0x4e13(%rip), %rcx      # 0xc978
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x30(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x34(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x2c(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Color::Execute()
void Color::Execute()
{
	int length = width * height;
	Pixel *data = new Pixel[length];
	for(int i = 0; i < length; i++){
		data[i].red = red;
		data[i].green = green;
		data[i].blue = blue;
	}
	outputImg.ResetSize(width,height);
        outputImg.SetBuffer(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl 0x28(%rcx), %eax
imull 0x2c(%rcx), %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7c39
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
movb %cl, %dl
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
imulq $0x3, %rsi, %rsi
addq %rsi, %rcx
movb %dl, (%rcx)
movl 0x34(%rax), %ecx
movb %cl, %dl
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
imulq $0x3, %rsi, %rsi
addq %rsi, %rcx
movb %dl, 0x1(%rcx)
movl 0x38(%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7bde
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
callq 0x3e90
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x3eb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: CheckSum::OutputCheckSum()
void CheckSum::OutputCheckSum()
{
	unsigned char redSum = 0;
	unsigned char greenSum = 0;
	unsigned char blueSum = 0;
        OneInputCheck();
	int numOfPixels = inputImg1->GetWidth() * inputImg1->GetHeight();
	Pixel *inBuffer1 = inputImg1->GetBuffer();

	for(int i = 0; i < numOfPixels; i++){
		redSum = (unsigned char) (redSum + inBuffer1[i].red);
		greenSum =(unsigned char) (greenSum + inBuffer1[i].green);
		blueSum = (unsigned char) (blueSum + inBuffer1[i].blue);
	}
        FILE *f_out;
        f_out = fopen("log/checksum", "w+");
        if(f_out == NULL){
        	f_out = fopen("../log/checksum", "w+");
        	if(f_out == NULL){
                	fprintf(stderr, "Failure opening output file");
                	exit(EXIT_FAILURE);
		}
        }
        fprintf( f_out, "CHECKSUM: %d, %d, %d\n", redSum, greenSum, blueSum);
        fclose(f_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
callq 0x3fa0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3db0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x34(%rbp)
movq 0x8(%rax), %rdi
callq 0x3dd0
movl -0x34(%rbp), %ecx
movl %eax, %edx
movq -0x30(%rbp), %rax
imull %edx, %ecx
movl %ecx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x3df0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7efd
movzbl -0x9(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
movb %al, -0x9(%rbp)
movzbl -0xa(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xb(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movb %al, -0xb(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e97
leaq 0x13dc(%rip), %rdi      # 0x92e0
leaq 0x1213(%rip), %rsi      # 0x911e
callq 0x3150
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7f5d
leaq 0x13bb(%rip), %rdi      # 0x92dd
leaq 0x11f5(%rip), %rsi      # 0x911e
callq 0x3150
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7f5b
movq 0x5098(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x11d7(%rip), %rsi      # 0x9121
movb $0x0, %al
callq 0x3180
movl $0x1, %edi
callq 0x3160
jmp 0x7f5d
movq -0x28(%rbp), %rdi
movzbl -0x9(%rbp), %edx
movzbl -0xa(%rbp), %ecx
movzbl -0xb(%rbp), %r8d
leaq 0x1378(%rip), %rsi      # 0x92ed
movb $0x0, %al
callq 0x3180
movq -0x28(%rbp), %rdi
callq 0x3100
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CodyNault[P]Image-Filter-Dataflow/src/logging.cpp
// Function: Logger::LogEvent(char const*)
void Logger::LogEvent(const char *event)
{
	if(logger == NULL){
		logger = fopen("log/log_file", "w");
        	if(logger == NULL){
			logger = fopen("../log/log_file", "w");
        		if(logger == NULL){
                		DataFlowException except("Logger", "Cannot lock log file!");
                		throw except;
			}
        	}
	}	
        fprintf(logger, "%s\n", event);
//	fprintf(stderr,"%s\n", event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x4cf9(%rip)      # 0xd180
jne 0x855a
leaq 0xf6a(%rip), %rdi       # 0x93fe
leaq 0xbfc(%rip), %rsi       # 0x9097
callq 0x3150
movq %rax, 0x4cd9(%rip)      # 0xd180
cmpq $0x0, 0x4cd1(%rip)      # 0xd180
jne 0x8558
leaq 0xf3f(%rip), %rdi       # 0x93fb
leaq 0xbd4(%rip), %rsi       # 0x9097
callq 0x3150
movq %rax, 0x4cb1(%rip)      # 0xd180
cmpq $0x0, 0x4ca9(%rip)      # 0xd180
jne 0x8556
leaq 0xf2b(%rip), %rsi       # 0x940b
leaq 0xf2b(%rip), %rdx       # 0x9412
leaq -0x410(%rbp), %rdi
movq %rdi, -0x430(%rbp)
callq 0x8420
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq -0x430(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x428(%rbp)
callq 0x4240
movq -0x428(%rbp), %rdi
leaq 0x4360(%rip), %rsi      # 0xc888
leaq -0x429f(%rip), %rdx     # 0x4290
callq 0x31c0
jmp 0x8588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x418(%rbp)
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x4290
jmp 0x857c
jmp 0x8558
jmp 0x855a
movq 0x4c1f(%rip), %rdi      # 0xd180
movq -0x8(%rbp), %rdx
leaq 0xebc(%rip), %rsi       # 0x9428
movb $0x0, %al
callq 0x3180
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
movq -0x418(%rbp), %rdi
callq 0x31d0
nopl (%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/main.cpp
// Function: printet(etree*, int)
void printet(et *e,int n){
	int s;
	for(int k=0;k<n;k++){
		printf("par[%d] is %d,chl are ",k,e->par[k]);
		s=(int)e->chl->at(k)->size();
		for(int j=0;j<s;j++){
			printf("%d ",e->chl->at(k)->at(j));

		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13a0
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x5cee(%rip), %rdi      # 0x7008
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15e0
movq (%rax), %rdi
callq 0x1680
movl %eax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1384
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15e0
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0x16a0
movl (%rax), %esi
leaq 0x5cad(%rip), %rdi      # 0x701f
movb $0x0, %al
callq 0x1030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1344
leaq 0x5d7b(%rip), %rdi      # 0x7106
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12f6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/main.cpp
// Function: print_cs(std::map<int, std::vector<int, std::allocator<int>>*, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>*>>>*)
void print_cs(map<int,vector<int>* > *e){
	int s,n=e->size();
	for(int k=0;k<n;k++){
		printf("col_struct[%d] is  ",k);
		s=(int)e->at(k)->size();
		for(int j=0;j<s;j++){
			printf("%d ",e->at(k)->at(j));

		}
		printf("\n");
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16e0
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1463
movl -0x14(%rbp), %esi
leaq 0x5c3e(%rip), %rdi      # 0x7023
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15e0
movq (%rax), %rdi
callq 0x1680
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1447
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15e0
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0x16a0
movl (%rax), %esi
leaq 0x5bea(%rip), %rdi      # 0x701f
movb $0x0, %al
callq 0x1030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x140b
leaq 0x5cb8(%rip), %rdi      # 0x7106
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13cf
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BhanuPrakashN[P]sparse_chol/main.cpp
// Function: main
int main(){
	sm *A;
	FILE *f;
	f=fopen("input.txt","r");
	A=load(f);
	fclose(f);
	sm *B=TripletToCC(A);
	int n=B->n;
	printf("given matrix A:\n");

	

	clock_t t = clock();

	et *e=buildTree(B);

	map<int,vector<int>* > * col_strut=col_structure(e,B);

	sm *L=sm_chol(B,e,col_strut);

	printf("\nTime taken: %.4fs\n", (float)(clock() - t)/CLOCKS_PER_SEC);


	printf("chol factor L:\n");
	for(int j=0;j<n;j++){
		for(int p=L->p[j];p<L->p[j+1];p++){
			printf("%d %d %g\n",L->i[p]+1,j+1,L->x[p]);
		}
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5bb1(%rip), %rdi      # 0x7037
leaq 0x5bb4(%rip), %rsi      # 0x7041
callq 0x1130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f70
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
leaq 0x5b79(%rip), %rdi      # 0x7043
movb $0x0, %al
callq 0x1030
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x24d0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2c10
movq %rax, -0x48(%rbp)
callq 0x10b0
subq -0x30(%rbp), %rax
cvtsi2ss %rax, %xmm0
movss 0x5ae1(%rip), %xmm1     # 0x7004
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x5b22(%rip), %rdi      # 0x7054
movb $0x1, %al
callq 0x1030
leaq 0x5b28(%rip), %rdi      # 0x7068
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x15d3
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x4c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x48(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x4c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x15c3
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
movl -0x4c(%rbp), %edx
addl $0x1, %edx
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x50(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x5ac7(%rip), %rdi      # 0x7078
movb $0x1, %al
callq 0x1030
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x1568
jmp 0x15c5
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x154e
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: sm_insert(smatrix*, int, int, double)
int sm_insert(sm *A,int i,int j,double x){ //insert entry(i,j,x) into triplet form
	if(!TRIPLET(A)||i<0||j<0) return 0;
	if(A->nz >= A->nzmax)smrealloc(A,2*(A->nzmax));
	A->i[A->nz]=i;
	A->p[A->nz]=j;
	A->x[A->nz]=x;
	A->nz++;
	A->m=MAX(A->m,i+1);
	A->n=MAX(A->n,j+1);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bc4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x1bc4
cmpl $0x0, -0x14(%rbp)
jl 0x1bc4
cmpl $0x0, -0x18(%rbp)
jge 0x1bd0
movl $0x0, -0x4(%rbp)
jmp 0x1caa
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1bf0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
shll %esi
callq 0x1cc0
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1c60
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x1c69
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1c90
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x1c99
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smrealloc(smatrix*, int)
void smrealloc (sm *A, int nzmax)
{
    A->nzmax = (nzmax <= 0) ? (A->p [A->n]) : nzmax ;
    A->i = (int*)realloc (A->i, MAX(nzmax,1)*sizeof(int)) ;
    if (A->nz >= 0) A->p = (int*)realloc (A->p,MAX(nzmax,1)*sizeof(int)) ;
    if (A->x) A->x = (double*)realloc (A->x, MAX(nzmax,1)*sizeof(double)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x1ced
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
jmp 0x1cf3
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x1d16
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d20
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d20
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x11b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x1d8a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x1d62
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d6c
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d6c
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x11b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1dd7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x1daf
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1db9
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1db9
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x11b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smalloc(int, int, int, int, int)
sm *smalloc(int m, int n, int nzmax, int values, int triplet){
	sm *A = (sm*)calloc(1,sizeof(sm));
	A->m = m ;
	A->n = n ;
	A->nzmax = nzmax;
	A->nz = triplet? 0:-1;
	A->p=(int*)malloc((triplet? nzmax : n+1)*sizeof(int));
	A->i=(int*)malloc(nzmax*sizeof(int));
	A->x=values ? (double*)malloc(nzmax*sizeof(double)) : NULL ;
	return ((!A->p || !A->i || (values && !A->x)) ? smfree (A) : A) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x1e4d
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1e56
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x1ea1
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1150
movq %rax, -0x30(%rbp)
jmp 0x1ea9
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x1ea9
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1edc
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1edc
cmpl $0x0, -0x10(%rbp)
je 0x1eeb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1eeb
movq -0x20(%rbp), %rdi
callq 0x1f00
movq %rax, -0x38(%rbp)
jmp 0x1ef3
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smfree(smatrix*)
sm *smfree (sm *A){
    if (!A) return (NULL) ;	
    free (A->p) ;
    free (A->i) ;
    free (A->x) ;
    if(A)free(A);
    return NULL;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f1d
movq $0x0, -0x8(%rbp)
jmp 0x1f5c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1140
cmpq $0x0, -0x10(%rbp)
je 0x1f54
movq -0x10(%rbp), %rdi
callq 0x1140
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: load(_IO_FILE*)
sm *load (FILE *f){
    int i, j ;   
    double x ;
    sm *A ;
    if (!f) return (NULL) ;                             
    A = smalloc (0, 0, 1, 1, 1) ;                    
    while (fscanf (f, "%d %d %lg\n", &i, &j, &x) == 3)
    {
        if (!sm_insert (A,  i-1,  j-1, x)) return (smfree (A)) ;
    }
    return (A) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f8d
movq $0x0, -0x8(%rbp)
jmp 0x2001
xorl %esi, %esi
movl $0x1, %r8d
movl %esi, %edi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x1de0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5123(%rip), %rsi      # 0x70d4
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
movb $0x0, %al
callq 0x11d0
cmpl $0x3, %eax
jne 0x1ff9
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
movsd -0x20(%rbp), %xmm0
callq 0x1b90
cmpl $0x0, %eax
jne 0x1ff7
movq -0x28(%rbp), %rdi
callq 0x1f00
movq %rax, -0x8(%rbp)
jmp 0x2001
jmp 0x1fa6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: print(smatrix*)
int print(sm *A){
    printf("triplet of %d by %d\n",A->m,A->n);
    printf("  i      j      x \n");
    for(int p=0;p<A->nz;p++){
        printf("%6d %6d %6g\n",A->i[p],A->p[p],A->x[p]);

    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x50ae(%rip), %rdi      # 0x70df
movb $0x0, %al
callq 0x1030
leaq 0x50b5(%rip), %rdi      # 0x70f4
movb $0x0, %al
callq 0x1030
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x20a1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x5079(%rip), %rdi      # 0x7108
movb $0x1, %al
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x204d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)