LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/Client.cpp
// Function: messageListener(void*)
void *messageListener(void *Args)
{
	sleep(2); // Give it some time to start
	char msg_buff[128] = {0};
	do
	{
		recv(sockfd, msg_buff, 127, 0);
		printf("Received a message: %s\n", msg_buff);
		printf("\n");
		memset(msg_buff, 0, 128);
		sleep(2);
	} while (strcmp(msg_buff, "close") != 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl $0x2, %edi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq 0x2d1e(%rip), %r14      # 0x6018
movl 0x4ed4(%rip), %edi      # 0x81d4
movl $0x7f, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
callq 0x2260
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movl $0x2, %edi
callq 0x2170
jmp 0x32fa
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::subGenerateGraph(TiXmlNode*)
Node* GraphGenerator::subGenerateGraph(TiXmlNode* pParent)
    {
        //if ( !pParent ) return;

        TiXmlNode* pChild;
        TiXmlText* pText;
        int t = pParent->Type();
        int num;
         
        Node* rootNode = getNodeDataFromThisNode(pParent->ToElement()); 

        string nodeTag = "Node";
        //if(pParent->FirstChild)
        for ( pChild = pParent->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) 
        {
            if(nodeTag.compare(pChild->Value()) == 0) {
                rootNode->addChildNode(subGenerateGraph(pChild));
            }
            
        }

        return rootNode;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x58(%rax)
movq %rax, %rsi
callq 0x9e0c
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3c83(%rip), %rsi      # 0xdd50
leaq 0x3c80(%rip), %rdx      # 0xdd54
movq %rsp, %rdi
callq 0xa6dc
movq 0x28(%r15), %r15
testq %r15, %r15
je 0xa11b
movq %rsp, %r12
movq 0x38(%r15), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x40d0
testl %eax, %eax
jne 0xa112
movq %r14, %rdi
movq %r15, %rsi
callq 0xa096
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb3e2
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0xa0e8
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa131
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa15b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::dump_to_stdout(char const*)
Node* GraphGenerator::dump_to_stdout(const char* pFilename)
    {
        TiXmlDocument doc(pFilename);
        bool loadOkay = doc.LoadFile();
        if (loadOkay)
        {
            return dump_to_stdout( &doc ); // defined later in the tutorial
        }
        else
        {
            printf("Failed to load file \"%s\"\n", pFilename);
            return NULL;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x5e82
movq %r15, %rdi
xorl %esi, %esi
callq 0x60e6
testb %al, %al
je 0xa2b2
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa164
movq %rax, %r14
jmp 0xa2c6
leaq 0x3ace(%rip), %rdi      # 0xdd87
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4080
movq %rsp, %rdi
callq 0x99e0
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x99e0
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/PMMLNode.cpp
// Function: Node::Node(int, std::vector<double, std::allocator<double>>, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
Node::Node(int score, vector<double> score_distribution, double node_record_count, string predicate_feature, string predicate_operator, double predicate_value) {
	this->score = score;
	this->score_distribution = score_distribution;
	this->node_record_count = node_record_count;
	this->predicate_feature = predicate_feature;
	this->predicate_operator = predicate_operator;
	this->predicate_value = predicate_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movq %r8, %r12
movq %rcx, %rbp
movsd %xmm0, 0x20(%rsp)
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x48(%rbx), %r13
leaq 0x58(%rbx), %r14
movq %r14, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movb %al, 0x58(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movups %xmm0, 0x70(%rbx)
movq %rax, 0x80(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rbx)
movq %rdi, 0x10(%rsp)
movq %rdx, %rsi
callq 0xa5a0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4160
movq %r13, %rdi
movq %r12, %rsi
callq 0x4160
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb394
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq (%r13), %rdi
cmpq %r14, %rdi
je 0xb3a8
movq (%r14), %rsi
incq %rsi
callq 0x4250
movq (%r15), %rdi
cmpq (%rsp), %rdi
je 0xb3c0
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4250
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb3d9
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq %r12, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/pmml_score.cpp
// Function: Score::generateProb(Node*)
vector<double> generateProb(Node* root) {
		
		vector<double> result;
		if(root == NULL) {
			result.resize(5,0.0);
			return result;
		}
		
		getScore(root);
		
		if(resPMMLNode == NULL) {
			resPMMLNode = root;
		}
		
		for(int i=0; i<5; i++) {
			double prob = (resPMMLNode->score_distribution[i])/(resPMMLNode->node_record_count);
			result.push_back(prob);
		}

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0xbb59
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xc0b6
cmpq $0x0, (%r14)
jne 0xbb0e
movq %r15, (%r14)
xorl %r12d, %r12d
movq %rsp, %r15
movq (%r14), %rax
movq 0x8(%rax), %rcx
movsd (%rcx,%r12,8), %xmm0
divsd 0x20(%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xbb43
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xbb4e
movq %rbx, %rdi
movq %r15, %rdx
callq 0xc478
incq %r12
cmpq $0x5, %r12
jne 0xbb14
jmp 0xbb70
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x5, %esi
movq %rbx, %rdi
callq 0xa56c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbb83
jmp 0xbb83
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbb9a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/pmml_score.cpp
// Function: Score::getScore(Node*)
void getScore(Node *parent) {
		if(resPMMLNode != NULL) return;
		for(int i=0; i< parent -> childNodes.size(); i++) {
			Node *currPMMLNode = parent -> childNodes.at(i);
			if(isPredicateTrue(currPMMLNode)) {
				//cout << "predicate true " <<currPMMLNode-> node_record_count << endl;
				getScore(currPMMLNode);
			}
		}
		if(resPMMLNode == NULL) {
			resPMMLNode = parent;
		}
		//cout << "resPMML node record count " << resPMMLNode->node_record_count << endl;
	}

// Assembly:
cmpq $0x0, (%rdi)
je 0xc0bd
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %rax
cmpq %rax, 0x78(%rsi)
je 0xc113
xorl %r12d, %r12d
movq (%rax,%r12,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc122
testb %al, %al
je 0xc0f6
movq %r14, %rdi
movq %r15, %rsi
callq 0xc0b6
incq %r12
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0xc0d8
cmpq $0x0, (%r14)
jne 0xc116
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/muk343[P]pmml/pmml_score.cpp
// Function: Score::isPredicateTrue(Node*)
bool isPredicateTrue(Node *node) {
		int feature_idx = getFeatureIndex(node -> predicate_feature);
		if(predicateMap[node->predicate_operator](node -> predicate_value, input_vec[feature_idx])) {
			return true;
		} 
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rsi), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xc2ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc1c6
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc177
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
leaq 0x20(%rbx), %rdi
leaq 0x48(%r14), %rsi
callq 0xc252
movsd 0x68(%r14), %xmm0
movslq %ebp, %rcx
movq 0x8(%rbx), %rdx
movsd (%rdx,%rcx,8), %xmm1
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc1be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/main.cpp
// Function: startWorker(void*)
void *startWorker(void *arg) {
  Server *serv = ((Worker*)arg)->serv_;
  int id = ((Worker*)arg)->id_;
  serv->run(id);
  return NULL;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x1a248
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/Config.cpp
// Function: Config::Config(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Config::Config(std::string &path) : path_(path) {
  workers_ = 0;
  fd_ = open(path_.c_str(), O_RDONLY);
  if (fd_ < 0)
    throw webserv_exception("could not open configuration file : %", 0, path_);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x6c2a
leaq 0x38(%rbx), %r13
movq %r13, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
movl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x4320
movl %eax, 0x20(%rbx)
testl %eax, %eax
js 0x5a9e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x41d0
movq %rax, %r14
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1f5c5(%rip), %rsi     # 0x25080
leaq 0x1f5e3(%rip), %rdx     # 0x250a5
leaq 0x8(%rsp), %rdi
callq 0x579e
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x6c2a
movb $0x1, %al
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x65b0
movl $0x0, 0x4(%rsp)
leaq 0x2c1ee(%rip), %rsi     # 0x31d00
leaq 0xeaf(%rip), %rdx       # 0x69c8
movq %r14, %rdi
callq 0x4760
movq %rax, %r15
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5b40
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5b57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
cmpb $0x0, 0x4(%rsp)
jne 0x5b7f
jmp 0x5b8c
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5b7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x5b7f
movq %rax, %r15
movq %r14, %rdi
callq 0x4310
jmp 0x5b8c
movq %rax, %r15
leaq 0x48(%rbx), %r14
leaq 0x60(%rbx), %rdi
callq 0x69e2
movq %r14, %rdi
callq 0x6a2c
movq 0x28(%rbx), %rdi
cmpq %r13, %rdi
je 0x5bb6
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5bca
movq (%r12), %rsi
incq %rsi
callq 0x4470
movq %r15, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/Config.cpp
// Function: Config::clear()
void Config::clear() {
  if (fd_ > 0) {
    close(fd_);
    fd_ = 0;
  }
  tokens_.clear();
  file_content_.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %edi
testl %edi, %edi
jle 0x5c3f
callq 0x4850
movl $0x0, 0x20(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x6cfe
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movb $0x0, (%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/InputArgs.cpp
// Function: InputArgs::InputArgs(int, char**)
InputArgs::InputArgs(int argc, char **argv) : argc_(argc), argv_(argv), path_("./config/default.conf"), log_level_(INFO) {
  options_["h"];
  options_["-help"];
  options_["t"];
  options_["-test"];
  options_["u"];
  options_["-uri"];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
leaq 0x1cd7a(%rip), %rsi     # 0x251c3
leaq 0x1cd88(%rip), %rdx     # 0x251d8
movq %rbx, %rdi
callq 0x579e
movl $0x1, 0x30(%r15)
leaq 0x38(%r15), %r14
leaq 0x40(%r15), %rax
movl $0x0, 0x40(%r15)
xorl %ecx, %ecx
movq %rcx, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %rcx, 0x60(%r15)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e150(%rip), %rsi     # 0x265e2
leaq 0x1e14a(%rip), %rdx     # 0x265e3
movq %rsp, %rdi
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x84c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cd0a(%rip), %rsi     # 0x251d9
leaq 0x1cd08(%rip), %rdx     # 0x251de
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x84fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1e25c(%rip), %rsi     # 0x26765
leaq 0x1e256(%rip), %rdx     # 0x26766
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8536
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cc9c(%rip), %rsi     # 0x251df
leaq 0x1cc9a(%rip), %rdx     # 0x251e4
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8570
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cc68(%rip), %rsi     # 0x251e5
leaq 0x1cc62(%rip), %rdx     # 0x251e6
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x85aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cc30(%rip), %rsi     # 0x251e7
leaq 0x1cc2d(%rip), %rdx     # 0x251eb
callq 0x579e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x90b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x85e4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8606
jmp 0x8621
jmp 0x8606
jmp 0x8621
jmp 0x8606
jmp 0x8621
jmp 0x8606
jmp 0x8621
jmp 0x8606
jmp 0x8621
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8624
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x8624
movq %rax, %r15
movq %r14, %rdi
callq 0x92cc
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x8640
movq (%r12), %rsi
incq %rsi
callq 0x4470
movq %r15, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/InputArgs.cpp
// Function: InputArgs::helpText[abi:cxx11]()
std::string InputArgs::helpText() {
  std::string text = "";

  text += "Usage: webserv [options] [config_file]\n";
  text += "\nOptions: \n";
  text += "  -h, --help         : this help text\n";
  text += "  -l, --log [LEVEL]  : set log level (between 0 and 2)\n";
  text += "  -t, --test         : test config and exit\n";
  text += "  -u, --uri          : keep location uri on rooting (similar to nginx)";

  return text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x1cd34(%rip), %rdx     # 0x25a78
movq %rdx, %rsi
callq 0x579e
leaq 0x1c4e5(%rip), %rsi     # 0x25238
movq %rbx, %rdi
callq 0x4840
leaq 0x1c4fe(%rip), %rsi     # 0x25260
movq %rbx, %rdi
callq 0x4840
leaq 0x1c4fb(%rip), %rsi     # 0x2526c
movq %rbx, %rdi
callq 0x4840
leaq 0x1c513(%rip), %rsi     # 0x25293
movq %rbx, %rdi
callq 0x4840
leaq 0x1c53c(%rip), %rsi     # 0x252cb
movq %rbx, %rdi
callq 0x4840
leaq 0x1c55a(%rip), %rsi     # 0x252f8
movq %rbx, %rdi
callq 0x4840
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8dc5
movq (%r15), %rsi
incq %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4790
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::setup(InputArgs&)
void RequestConfig::setup(InputArgs &options) {
  ServerConfig *server = getServerForRequest(servers_);
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server, request_.target_);

  server_ = server;
  location_ = server;

  target_ = request_.target_;

  if (location) {
    location_ = location;
    if (!options.location() && request_.target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
callq 0x98b4
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1238e
cmpl $0x3, %eax
jl 0x983a
movq (%rbx), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9b86
movq %rax, %r12
jmp 0x983d
xorl %r12d, %r12d
movq %r15, 0x20(%rbx)
movq %r15, 0x28(%rbx)
movq (%rbx), %rsi
addq $0x40, %rsi
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x4230
testq %r12, %r12
je 0x98a8
movq %r12, 0x28(%rbx)
movq %r14, %rdi
callq 0x8fc0
testb %al, %al
jne 0x98a8
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rcx
xorl %edx, %edx
callq 0x4780
cmpq $-0x1, %rax
je 0x98a8
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::redirectLocation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RequestConfig::redirectLocation(std::string target) {
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server_, target);

  target_ = target;
  if (location) {
    location_ = location;
    if (target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1238e
cmpl $0x2, %eax
jle 0x9d92
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9b86
movq %rax, %r12
leaq 0x30(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4230
testq %r12, %r12
je 0x9dac
movq %r12, 0x28(%rbx)
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4780
cmpq $-0x1, %rax
je 0x9dac
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b0
addq $0x30, %rbx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::methodAccepted(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool RequestConfig::methodAccepted(std::string &method) {
  std::vector<std::string> methods = location_->methods_;

  if (methods.empty())
    return true;
  if (std::find(methods.begin(), methods.end(), method) != methods.end())
    return true;
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl $0xe8, %esi
addq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x7a00
movq (%r14), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0x9e82
movq %rbx, %rdx
callq 0xb007
cmpq 0x8(%rsp), %rax
setne %bl
jmp 0x9e84
movb $0x1, %bl
movq %rsp, %rdi
callq 0x6a2c
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a2c
movq %rbx, %rdi
callq 0x4790
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::operator=(ServerConfig const&)
ServerConfig	&ServerConfig::operator=(const ServerConfig &copy) {
  client_max_body_size_ = copy.client_max_body_size_;
  root_ = copy.root_;
  error_codes_ = copy.error_codes_;
  index_ = copy.index_;
  cgi_ = copy.cgi_;
  cgi_bin_ = copy.cgi_bin_;
  autoindex_ = copy.autoindex_;
  credentials_ = copy.credentials_;
  return (*this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movl $0xa8, %edi
addq %rdi, %rsi
addq %rbx, %rdi
callq 0x4230
movl $0x100, %edi            # imm = 0x100
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xcfaa
movl $0x130, %edi            # imm = 0x130
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xcc34
movl $0x148, %edi            # imm = 0x148
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xd272
movl $0x178, %edi            # imm = 0x178
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x4230
movb 0x98(%r14), %al
movb %al, 0x98(%rbx)
addq $0x78, %r14
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x4230
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::error_page(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::error_page(std::vector<std::string>::iterator &it) {
  std::vector<int> codes;

  while (it->find_first_not_of("0123456789") == std::string::npos) {
    codes.push_back(ft::stoi(*it++));
  }
  for (std::vector<int>::iterator it2 = codes.begin(); it2 != codes.end(); it2++) {
    error_codes_[*it2] = *it;
  }
  if (*++it != ";")
    throw std::runtime_error("double value in 'listen'");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rdi
leaq 0x190e8(%rip), %rsi     # 0x251f1
movl $0xa, %ecx
xorl %edx, %edx
callq 0x4730
cmpq $-0x1, %rax
jne 0xc1ba
movq %rsp, %r15
leaq 0x1c(%rsp), %r12
leaq 0x190c3(%rip), %r13     # 0x251f1
movq (%rbx), %rdi
leaq 0x20(%rdi), %rax
movq %rax, (%rbx)
xorl %esi, %esi
movl $0xa, %edx
callq 0x24471
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xc161
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0xc16c
movq %r15, %rdi
movq %r12, %rdx
callq 0xdefc
movq (%rbx), %rdi
movl $0xa, %ecx
movq %r13, %rsi
xorl %edx, %edx
callq 0x4730
cmpq $-0x1, %rax
je 0xc12e
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
je 0xc1ba
addq $0x100, %r14            # imm = 0x100
movq (%rbx), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xcec8
movq %rax, %rdi
movq %r12, %rsi
callq 0x4230
addq $0x4, %r15
cmpq 0x8(%rsp), %r15
jne 0xc196
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x197c0(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc1f8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc1ea
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %r14
leaq 0x19234(%rip), %rsi     # 0x25440
movq %rax, %rdi
callq 0x4170
movq 0x25dd5(%rip), %rsi     # 0x31ff0
movq 0x25d86(%rip), %rdx     # 0x31fa8
movq %r14, %rdi
callq 0x4760
jmp 0xc23b
movq %rax, %rbx
movq %r14, %rdi
callq 0x4310
jmp 0xc23e
jmp 0xc23b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc254
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::client_max_body_size(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::client_max_body_size(std::vector<std::string>::iterator &it) {
  if (it->find_first_not_of("0123456789") != std::string::npos)
      throw std::runtime_error("unexpected symbols in client_max_body_size");
  client_max_body_size_ = ft::stoi(*it);
  if (*++it != ";")
    throw std::runtime_error("double value in 'client_max_body_size_'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x18f07(%rip), %rsi     # 0x251f1
movl $0xa, %ecx
xorl %edx, %edx
callq 0x4730
cmpq $-0x1, %rax
jne 0xc336
movq (%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x24471
cltq
movq %rax, 0xa0(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x19666(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc354
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x1910f(%rip), %rsi     # 0x25459
movq %rax, %rdi
callq 0x4170
jmp 0xc370
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x1911c(%rip), %rsi     # 0x25484
movq %rax, %rdi
callq 0x4170
movq 0x25c79(%rip), %rsi     # 0x31ff0
movq 0x25c2a(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4760
jmp 0xc388
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4790
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::autoindex(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::autoindex(std::vector<std::string>::iterator &it) {
  if (*it == "on")
    autoindex_ = true;
  else if (*it == "off")
    autoindex_ = false;
  else
    throw std::runtime_error("unknown value in 'autoindex'");

  if (*++it != ";")
    throw std::runtime_error("double value in 'autoindex'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x19c5c(%rip), %rsi     # 0x260de
callq 0x40f0
testl %eax, %eax
je 0xc4a2
movq (%rbx), %rdi
leaq 0x19c82(%rip), %rsi     # 0x26117
callq 0x40f0
testl %eax, %eax
jne 0xc4eb
xorl %eax, %eax
jmp 0xc4a4
movb $0x1, %al
movb %al, 0x98(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x194cf(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc4cd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x19016(%rip), %rsi     # 0x254f7
movq %rax, %rdi
callq 0x4170
jmp 0xc507
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x18fdb(%rip), %rsi     # 0x254da
movq %rax, %rdi
callq 0x4170
movq 0x25ae2(%rip), %rsi     # 0x31ff0
movq 0x25a93(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4760
jmp 0xc51f
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::server(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::server(std::vector<std::string>::iterator &it) {
  if (*it != "{")
    throw std::runtime_error("missing opening bracket in server block");
  while (*(++it) != "}") {
    if (ServerConfig::directive_[*it])
      (this->*(ServerConfig::directive_[*it]))(++it);
    else
      throw std::runtime_error("invalid directive '" + *it + "' in 'server'");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x1897f(%rip), %rsi     # 0x250a9
callq 0x40f0
testl %eax, %eax
jne 0xc859
movq (%r14), %rdi
addq $0x20, %rdi
movq %rdi, (%r14)
leaq 0x18963(%rip), %rsi     # 0x250ab
callq 0x40f0
testl %eax, %eax
je 0xc7b1
leaq 0x25da0(%rip), %r15     # 0x324f8
leaq 0x1894c(%rip), %r12     # 0x250ab
movq (%r14), %rsi
movq %r15, %rdi
callq 0xce4c
cmpq $0x0, (%rax)
je 0xc7be
movq (%r14), %rsi
movq %r15, %rdi
callq 0xce4c
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0xc792
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
addq $0x20, (%r14)
movq %r14, %rsi
callq *%rcx
movq (%r14), %rdi
addq $0x20, %rdi
movq %rdi, (%r14)
movq %r12, %rsi
callq 0x40f0
testl %eax, %eax
jne 0xc75f
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x18c1e(%rip), %rsi     # 0x253f3
movq %rsp, %rdi
callq 0x568a
leaq 0x18c23(%rip), %rsi     # 0x25407
movq %rsp, %rdi
callq 0x4840
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc80d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xc81a
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x46e0
xorl %ebp, %ebp
movq 0x257a6(%rip), %rsi     # 0x31ff0
movq 0x25757(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4760
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x18b5e(%rip), %rsi     # 0x253cb
movq %rax, %rdi
callq 0x4170
movq 0x25774(%rip), %rsi     # 0x31ff0
movq 0x25725(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4760
jmp 0xc8e9
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xc8a7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
testb %bpl, %bpl
jne 0xc8ec
jmp 0xc8f4
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0xc8ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: is_loc_modifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool is_loc_modifier(std::string &str) {
  return (str == "=" ||
          str == "~" ||
          str == "~*" ||
          str == "^~");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18fe6(%rip), %rsi     # 0x258ef
callq 0x40f0
movb $0x1, %bpl
testl %eax, %eax
je 0xc950
leaq 0x18c2e(%rip), %rsi     # 0x2554a
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
je 0xc950
leaq 0x18c17(%rip), %rsi     # 0x25546
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
je 0xc950
leaq 0x18c07(%rip), %rsi     # 0x25549
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/CGI.cpp
// Function: CGI::~CGI()
CGI::~CGI() {
  free(argv_[0]);
  free(argv_[1]);
  if (env_)
    ft::free_tab(env_);
  tmp_file_.close();
  tmp_file_.unlink();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d0(%rdi), %rdi
callq 0x4550
movq 0x1d8(%rbx), %rdi
callq 0x4550
movq 0x1c8(%rbx), %rdi
testq %rdi, %rdi
je 0xf332
callq 0x24a30
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x1c8a8
movq %r14, %rdi
callq 0x1d5e4
leaq 0x198(%rbx), %rdi
callq 0x8314
movq %r14, %rdi
callq 0x1c818
movq 0xd8(%rbx), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0xf37b
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0xb8(%rbx), %rdi
leaq 0xc8(%rbx), %rax
cmpq %rax, %rdi
je 0xf399
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0xf3b7
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0xf3d2
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0xf3ea
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0xf402
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0xf421
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4470
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5793
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Client.cpp
// Function: Client::timeout()
bool Client::timeout() {
  if (request_) {
    time_t current_time = ft::get_current_time_in_sec();
    if (current_time - request_->get_start_timer_in_sec() > START_TIMEOUT
      || current_time - request_->get_last_timer_in_sec() > LAST_TIMEOUT) {
      if (request_->timeout())
        return true;
    }
  }
  return false;
}

// Assembly:
cmpq $0x0, 0x38(%rdi)
je 0x10e72
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24ac9
movq %rax, %r14
movq 0x38(%rbx), %rdi
callq 0x12396
movq %r14, %rcx
subq %rax, %rcx
cmpq $0x12c, %rcx            # imm = 0x12C
jg 0x10e57
movq 0x38(%rbx), %rdi
callq 0x1239e
subq %rax, %r14
cmpq $0x97, %r14
jl 0x10e68
movq 0x38(%rbx), %rdi
callq 0x12372
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10e6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::Request()
Request::Request() {
  body_offset_ = 0;
  chunk_size_ = 0;
  status_ = FIRST_LINE;
  protocol_ = "HTTP/1.1";
  gettimeofday(&start_timer_, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %r12
movq %r12, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r15
movq %r15, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x80(%rdi), %r14
leaq 0x90(%rdi), %rbp
movq %rbp, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movb %al, 0x90(%rdi)
leaq 0xb0(%rdi), %r13
movq %r13, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
leaq 0xc8(%rdi), %rcx
movl %eax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rcx, 0xe0(%rdi)
movl %eax, 0x120(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rdi)
leaq 0x14778(%rip), %rcx     # 0x25772
movl $0x8, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4690
addq $0xf8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x46d0
movq %r15, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %rax, %r15
leaq 0xc0(%rbx), %rdi
callq 0x123a6
movq 0xa0(%rbx), %rdi
cmpq %r13, %rdi
je 0x1105c
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x11070
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq 0x60(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x1108b
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x40(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x110a6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x20(%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x110c1
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x110db
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq %r15, %rdi
callq 0x4790
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int Request::parse(std::string &buffer) {
  size_t ret = 0;

  gettimeofday(&last_timer_, NULL);

  buffer_ += buffer;
  buffer.clear();

  if (status_ == FIRST_LINE)
    ret = method_line();
  if (status_ == HEADERS)
    ret = headers();
  if (status_ == PREBODY)
    ret = prebody();
  if (status_ == BODY)
    ret = body();
  if (status_ == CHUNK)
    ret = chunk();
  if (status_ == COMPLETE || ret == 1) {
    status_ = COMPLETE;
    return ret;
  }
  else if (status_ == ERROR || ret > 1) {
    status_ = ERROR;
    return ret;
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x108, %rdi            # imm = 0x108
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x46d0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4100
movq $0x0, 0x8(%r15)
movq (%r15), %rax
movb $0x0, (%rax)
movl 0x120(%rbx), %eax
testl %eax, %eax
jne 0x111e6
movq %rbx, %rdi
callq 0x1126e
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x1, %eax
jne 0x111fc
movq %rbx, %rdi
callq 0x1156a
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x2, %eax
jne 0x11212
movq %rbx, %rdi
callq 0x1195e
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x3, %eax
jne 0x11228
movq %rbx, %rdi
callq 0x11d5c
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x4, %eax
jne 0x1123e
movq %rbx, %rdi
callq 0x11dbc
movl %eax, %r14d
movl 0x120(%rbx), %eax
movl $0x5, %ecx
cmpl $0x5, %eax
je 0x1125e
cmpl $0x1, %r14d
je 0x1125e
movl $0x6, %ecx
cmpl $0x6, %eax
je 0x1125e
cmpl $0x2, %r14d
jb 0x11264
movl %ecx, 0x120(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::body()
int Request::body() {
  if (buffer_.length() >= length_) {
    req_body_.insert(body_offset_, buffer_, 0, length_);
    body_offset_ += buffer_.length();
    buffer_.clear();

    if (req_body_.length() == length_)
      return 1;
    else
      return 400;
  }
  return 0;
}

// Assembly:
movq 0x118(%rdi), %r8
xorl %eax, %eax
cmpq %r8, 0x8(%rdi)
jb 0x11dba
pushq %rbx
movq %rdi, %rbx
addq $0xa0, %rdi
movslq 0xf0(%rbx), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x44b0
movl 0x8(%rbx), %eax
addl %eax, 0xf0(%rbx)
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xa8(%rbx), %rax
cmpq 0x118(%rbx), %rax
movl $0x1, %ecx
movl $0x190, %eax            # imm = 0x190
cmovel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::chunk()
int Request::chunk() {
  size_t end;

  while ((end = buffer_.find("\r\n")) != std::string::npos) {
    if (chunk_status_ == CHUNK_SIZE) {
      std::string hex = buffer_.substr(0, end);
      chunk_size_ = ft::to_hex(hex);
      buffer_.erase(0, end + 2);
      chunk_status_ = CHUNK_BODY;
    } else if (chunk_status_ == CHUNK_BODY) {
      if (chunk_size_ == 0) {
        if (!buffer_.empty())
          return chunk_trailer();
        return 1;
      }
      req_body_ += buffer_.substr(0, end);
      buffer_.erase(0, end + 2);
      chunk_size_ = 0;
      chunk_status_ = CHUNK_SIZE;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x13a0b(%rip), %rsi     # 0x257df
xorl %ebp, %ebp
movl $0x2, %ecx
xorl %edx, %edx
callq 0x4780
cmpq $-0x1, %rax
je 0x11efd
movq %rax, %r13
leaq 0xa0(%rbx), %r14
leaq 0x8(%rsp), %r15
leaq 0x139dd(%rip), %r12     # 0x257df
movl 0x124(%rbx), %eax
testl %eax, %eax
je 0x11e6c
cmpl $0x1, %eax
jne 0x11edc
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4490
movq %r15, %rdi
callq 0x242f0
movl %eax, 0xf4(%rbx)
addq $0x2, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x40b0
movl $0x0, 0x124(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11edc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x11edc
cmpl $0x0, 0xf4(%rbx)
je 0x11f0e
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4490
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x4100
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11eb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0x2, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x40b0
movl $0x0, 0xf4(%rbx)
movl $0x1, 0x124(%rbx)
xorl %ebp, %ebp
movl $0x2, %ecx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4780
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x11e02
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
je 0x11f21
movq %rbx, %rdi
callq 0x120d2
movl %eax, %ebp
jmp 0x11efd
movl $0x1, %ebp
jmp 0x11efd
jmp 0x11f2a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11f49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4790
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::Response(RequestConfig&, int, int)
Response::Response(RequestConfig &config, int worker_id, int error_code) : config_(config), worker_id_(worker_id) {
  error_code_ = error_code;
  status_code_ = 0;
  total_sent_ = 0;
  header_size_ = 0;
  body_size_ = 0;
  redirect_code_ = 0;
  redirect_ = false;
  charset_ = "";
  initMethodMap();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1c5a8
movl %r15d, 0xac(%r14)
leaq 0xd0(%r14), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0xc0(%r14)
xorl %eax, %eax
movq %rax, 0xc8(%r14)
movb %al, 0xd0(%r14)
leaq 0xf0(%r14), %r13
movq %r13, 0xe0(%r14)
movq %rax, 0xe8(%r14)
movb %al, 0xf0(%r14)
leaq 0x118(%r14), %rbx
movq %rbx, 0x108(%r14)
movq %rax, 0x110(%r14)
movb %al, 0x118(%r14)
leaq 0x140(%r14), %r12
leaq 0x150(%r14), %r15
movq %r15, 0x140(%r14)
movq %rax, 0x148(%r14)
movb %al, 0x150(%r14)
leaq 0x160(%r14), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x168(%r14), %rcx
movl %eax, 0x168(%r14)
movq %rax, 0x170(%r14)
movq %rcx, 0x178(%r14)
movq %rcx, 0x180(%r14)
movq %rax, 0x188(%r14)
leaq 0x190(%r14), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x198(%r14), %rcx
movl %eax, 0x198(%r14)
movq %rax, 0x1a0(%r14)
movq %rcx, 0x1a8(%r14)
movq %rcx, 0x1b0(%r14)
movq %rax, 0x1b8(%r14)
movl %ebp, 0xa8(%r14)
movl %eax, 0xb8(%r14)
movq %rax, 0xb0(%r14)
movl %eax, 0x128(%r14)
movb %al, 0x100(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%r14)
leaq 0x132af(%rip), %rcx     # 0x25a78
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x4690
movq %r14, %rdi
callq 0x1287a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq 0x10(%rsp), %rdi
callq 0x8314
movq 0x18(%rsp), %rdi
callq 0x17cc2
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x1281a
movq (%r15), %rsi
incq %rsi
callq 0x4470
movq 0x108(%r14), %rdi
cmpq %rbx, %rdi
je 0x12831
movq (%rbx), %rsi
incq %rsi
callq 0x4470
movq 0xe0(%r14), %rdi
cmpq %r13, %rdi
je 0x12849
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq 0xc0(%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x12867
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4470
movq 0x20(%rsp), %rdi
callq 0x1c818
movq %rbp, %rdi
callq 0x4790
nop
// File: /workspace/github_cpp_makefile_star2_O3/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::initMethodMap()
void Response::initMethodMap() {
  methods_["GET"] = &Response::GET;
  methods_["HEAD"] = &Response::GET;
  methods_["POST"] = &Response::POST;
  methods_["PUT"] = &Response::PUT;
  methods_["DELETE"] = &Response::DELETE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12f05(%rip), %rsi     # 0x2579b
leaq 0x12f01(%rip), %rdx     # 0x2579e
movq %rsp, %rdi
callq 0x579e
addq $0x160, %rbx            # imm = 0x160
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b70
leaq 0x27e(%rip), %r15       # 0x12b3c
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x128df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12eb3(%rip), %rsi     # 0x2579f
leaq 0x12eb0(%rip), %rdx     # 0x257a3
callq 0x579e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b70
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12924
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12c5e(%rip), %rsi     # 0x2558f
leaq 0x12c5b(%rip), %rdx     # 0x25593
callq 0x579e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b70
leaq 0x6d5(%rip), %rcx       # 0x13024
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12970
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12e1a(%rip), %rsi     # 0x25797
leaq 0x12e16(%rip), %rdx     # 0x2579a
callq 0x579e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b70
leaq 0x7c1(%rip), %rcx       # 0x1315c
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x129bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12ddb(%rip), %rsi     # 0x257a4
leaq 0x12dda(%rip), %rdx     # 0x257aa
callq 0x579e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b70
leaq 0x863(%rip), %rcx       # 0x1324a
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12a08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x12a22
jmp 0x12a3d
jmp 0x12a22
jmp 0x12a3d
jmp 0x12a22
jmp 0x12a3d
jmp 0x12a22
jmp 0x12a3d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12a40
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x12a40
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4790