LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c80
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xd2d0
movq %rax, -0x30(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x44b0
movq -0x70(%rbp), %rdx
leaq 0x9664(%rip), %rsi      # 0x16e40
leaq -0x50(%rbp), %rdi
callq 0xdea0
jmp 0xd7e7
leaq -0x51(%rbp), %rdi
callq 0x42f0
movq -0x10(%rbp), %rdi
callq 0x9370
movq %rax, -0x80(%rbp)
jmp 0xd7ff
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd8c3
movq -0x18(%rbp), %rdi
callq 0x8ca0
movq %rax, -0x88(%rbp)
jmp 0xd824
movq -0x88(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x40f0
cmpl $0x0, %eax
jne 0xd89f
movq -0x78(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
callq 0xd780
movq %rax, -0x90(%rbp)
jmp 0xd85a
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x12220
jmp 0xd86f
jmp 0xd89f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x42f0
jmp 0xd8e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41c0
jmp 0xd8e7
jmp 0xd8a1
movq -0x18(%rbp), %rdi
callq 0x8e20
movq %rax, -0xa0(%rbp)
jmp 0xd8b3
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd807
movq -0x30(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41c0
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x44a0
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6850
movq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x6ac0
movb %al, -0xa1(%rbp)
jmp 0xdbcb
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x89(%rbp)
testb $0x1, -0x89(%rbp)
je 0xdc35
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xd8f0
movq %rax, -0xc0(%rbp)
jmp 0xdbfe
movq -0xc0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xa0(%rbp)
jmp 0xdc5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcd80
jmp 0xdc74
movq -0x18(%rbp), %rsi
leaq 0x9237(%rip), %rdi      # 0x16e77
xorl %eax, %eax
callq 0x4080
jmp 0xdc49
movq $0x0, -0x8(%rbp)
movl $0x1, -0xa0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcd80
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x44a0
// File: muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::traverse(Node*)
void GraphGenerator::traverse(Node* rootNode) {
        
        stack<Node *> node_stack;
        Node *curr = rootNode;

        node_stack.push(curr);

        while(!node_stack.empty()) {

            Node* temp = node_stack.top();
            node_stack.pop();
            cout<<"Score is: "<<temp->score<<" recordCount is: "<<temp->node_record_count<<endl;
            if (temp->childNodes.size() == 1) {
                cout<<"This has only one child";
                exit(-1);
            }

            if (temp->childNodes.size() == 2) {
                node_stack.push(temp->childNodes[0]);
                node_stack.push(temp->childNodes[1]);
            }
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xe3b0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0xe3e0
jmp 0xdcbd
jmp 0xdcbf
leaq -0x60(%rbp), %rdi
callq 0xe410
movb %al, -0x89(%rbp)
jmp 0xdcd0
movb -0x89(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdce1
jmp 0xde36
leaq -0x60(%rbp), %rdi
callq 0xe430
movq %rax, -0x98(%rbp)
jmp 0xdcf3
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe450
jmp 0xdd0c
movq 0x122b5(%rip), %rdi     # 0x1ffc8
leaq 0x9177(%rip), %rsi      # 0x16e91
callq 0x4270
movq %rax, -0xa0(%rbp)
jmp 0xdd28
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rax
movsd (%rax), %xmm0
callq 0x44f0
movq %rax, -0xa8(%rbp)
jmp 0xdd45
movq -0xa8(%rbp), %rdi
leaq 0x9149(%rip), %rsi      # 0x16e9c
callq 0x4270
movq %rax, -0xb0(%rbp)
jmp 0xdd61
movq -0xb0(%rbp), %rdi
movq -0x80(%rbp), %rax
movsd 0x20(%rax), %xmm0
callq 0x44f0
movq %rax, -0xb8(%rbp)
jmp 0xdd7f
movq -0xb8(%rbp), %rdi
movq 0x12223(%rip), %rsi     # 0x1ffb0
callq 0x42d0
jmp 0xdd94
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
callq 0xe470
cmpq $0x1, %rax
jne 0xdddd
movq 0x1221a(%rip), %rdi     # 0x1ffc8
leaq 0x90f9(%rip), %rsi      # 0x16eae
callq 0x4270
jmp 0xddbc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe4b0
jmp 0xde48
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
callq 0xe470
cmpq $0x2, %rax
jne 0xde31
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe490
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xe3e0
jmp 0xde0f
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
movl $0x1, %esi
callq 0xe490
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xe3e0
jmp 0xde2f
jmp 0xde31
jmp 0xdcbf
leaq -0x60(%rbp), %rdi
callq 0xe4b0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x44a0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x50(%rbp)
movq %rcx, -0x88(%rbp)
movq %r8, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0xe010
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x78(%rbp)
callq 0x43b0
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x70(%rbp)
callq 0x43b0
movq -0x60(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x68(%rbp)
callq 0x122a0
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
cvtsi2sdl -0xc(%rbp), %xmm0
movsd %xmm0, (%rax)
callq 0xe100
jmp 0x1219b
movq -0x88(%rbp), %rsi
movq -0x60(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rdi
callq 0x4060
jmp 0x121bb
movq -0x80(%rbp), %rsi
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x4060
jmp 0x121ce
movq -0x60(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x68(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x122c0
movq -0x70(%rbp), %rdi
callq 0x41c0
movq -0x78(%rbp), %rdi
callq 0x41c0
movq -0x58(%rbp), %rdi
callq 0xe350
movq -0x40(%rbp), %rdi
callq 0x44a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xe010
cmpq $0x0, -0x18(%rbp)
jne 0x1308d
movq -0x60(%rbp), %rdi
movq $0x0, -0x28(%rbp)
movl $0x5, %esi
leaq -0x28(%rbp), %rdx
callq 0xe030
jmp 0x13063
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x13115
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xe350
jmp 0x1312e
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14890
jmp 0x1309c
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x130b1
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x3c(%rbp)
cmpl $0x5, -0x3c(%rbp)
jge 0x1310a
movq -0x50(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movslq -0x3c(%rbp), %rsi
callq 0xe0e0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd (%rcx), %xmm0
movq (%rax), %rax
movsd 0x20(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x14940
jmp 0x130fd
jmp 0x130ff
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x130b8
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x13124
movq -0x60(%rbp), %rdi
callq 0xe350
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x44a0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x148b3
jmp 0x14935
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0xe470
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x14920
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movslq -0x14(%rbp), %rsi
callq 0x149b0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x149f0
testb $0x1, %al
jne 0x14906
jmp 0x14913
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14890
jmp 0x14915
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x148ba
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14935
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4140
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x14b30
movl %eax, -0x50(%rbp)
jmp 0x14a2f
leaq -0x40(%rbp), %rdi
callq 0x41c0
movl -0x50(%rbp), %eax
movq -0x60(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
callq 0x14b80
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xe0e0
movsd -0x70(%rbp), %xmm0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movsd (%rcx), %xmm1
callq *%rax
testb $0x1, %al
jne 0x14a91
jmp 0x14aae
movb $0x1, -0x1(%rbp)
jmp 0x14ab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41c0
jmp 0x14abd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x44a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2d950
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5200
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x90(%rbp)
callq 0x57b0
movq -0x78(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x88(%rbp)
callq 0x8b40
movq -0x78(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x80(%rbp)
callq 0x8b60
movq -0x78(%rbp), %rdi
movl $0x0, 0x24(%rdi)
callq 0x51f0
movq %rax, %rdi
xorl %esi, %esi
movb %sil, %al
callq 0x53c0
movl %eax, -0x70(%rbp)
jmp 0x7ce9
movq -0x98(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
jge 0x7df2
movb $0x1, -0x69(%rbp)
movl $0x30, %edi
callq 0x5250
movq %rax, -0xa8(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5960
movq -0xa0(%rbp), %rdx
leaq 0x3b337(%rip), %rsi     # 0x4306a
leaq -0x40(%rbp), %rdi
callq 0x6be0
jmp 0x7d3e
movq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5200
jmp 0x7d50
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
leaq -0x68(%rbp), %rcx
callq 0x8b80
jmp 0x7d68
movq -0xa8(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0x53f76(%rip), %rsi     # 0x5bcf0
leaq 0x10af(%rip), %rdx      # 0x8e30
callq 0x5920
jmp 0x7e2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7dfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7dca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5aa8
leaq -0x40(%rbp), %rdi
callq 0x5aa8
leaq -0x41(%rbp), %rdi
callq 0x55e0
testb $0x1, -0x69(%rbp)
jne 0x7de4
jmp 0x7df0
movq -0xa8(%rbp), %rdi
callq 0x53b0
jmp 0x7dfb
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x8e60
movq -0x88(%rbp), %rdi
callq 0x8ec0
movq -0x90(%rbp), %rdi
callq 0x5aa8
movq -0x78(%rbp), %rdi
callq 0x5aa8
movq -0x18(%rbp), %rdi
callq 0x5950
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x20(%rax)
jle 0x7ec1
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x5a50
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8f20
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x5740
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5960
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x33b19(%rip), %rsi     # 0x43a54
callq 0x6be0
jmp 0xff42
leaq -0x12(%rbp), %rdi
callq 0x55e0
movq -0x38(%rbp), %rdi
leaq 0x332cc(%rip), %rsi     # 0x43222
callq 0x5520
jmp 0xff5d
movq -0x38(%rbp), %rdi
leaq 0x332e2(%rip), %rsi     # 0x4324a
callq 0x5520
jmp 0xff6f
movq -0x38(%rbp), %rdi
leaq 0x332dc(%rip), %rsi     # 0x43256
callq 0x5520
jmp 0xff81
movq -0x38(%rbp), %rdi
leaq 0x332f1(%rip), %rsi     # 0x4327d
callq 0x5520
jmp 0xff93
movq -0x38(%rbp), %rdi
leaq 0x33317(%rip), %rsi     # 0x432b5
callq 0x5520
jmp 0xffa5
movq -0x38(%rbp), %rdi
leaq 0x33332(%rip), %rsi     # 0x432e2
callq 0x5520
jmp 0xffb7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xfffa
jmp 0xfff1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x55e0
jmp 0x10004
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5aa8
jmp 0x10004
movq -0x38(%rbp), %rdi
callq 0x5aa8
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5950
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x10(%rdi), %rsi
callq 0x122b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq (%rax), %rdi
callq 0x23950
cmpl $0x2, %eax
jle 0x12209
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rdx
addq $0x40, %rdx
callq 0x12790
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rdi)
movq (%rdi), %rsi
addq $0x40, %rsi
addq $0x30, %rdi
callq 0x5050
cmpq $0x0, -0x20(%rbp)
je 0x1229d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x103b0
testb $0x1, %al
jne 0x1229b
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
addq $0x50, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5a90
cmpq $-0x1, %rax
je 0x1229b
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rdi
addq $0x50, %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x50d0
jmp 0x1229d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq (%rax), %rdi
callq 0x23950
cmpl $0x2, %eax
jle 0x12b36
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x12790
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x5050
cmpq $0x0, -0x18(%rbp)
je 0x12ba3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5a90
cmpq $-0x1, %rax
je 0x12ba1
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rdi
addq $0x50, %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x50d0
jmp 0x12ba3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::match_regexp(std::vector<ServerConfig*, std::allocator<ServerConfig*>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ServerConfig *RequestConfig::match_regexp(std::vector<ServerConfig*> &locations, std::string &target) {
  regex_t reg;

  for (std::vector<ServerConfig*>::iterator it = locations.begin(); it != locations.end(); it++) {
    int flag = REG_NOSUB | REG_EXTENDED;

    if ((*it)->modifier_ == 3)
      flag |= REG_ICASE;

    int err = regcomp(&reg, (*it)->uri_.c_str(), flag);

    if (err == 0) {
      int match = regexec(&reg, target.c_str(), 0, NULL, 0);
      regfree(&reg);
      if (match == 0)
        return *it;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13a20
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13a90
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x13a50
testb $0x1, %al
jne 0x12bf7
jmp 0x12ca4
movl $0x9, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x13ac0
movq (%rax), %rax
cmpl $0x3, 0x70(%rax)
jne 0x12c19
movl -0x74(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x13ac0
movq (%rax), %rdi
addq $0x50, %rdi
callq 0x51f0
movq %rax, %rsi
movl -0x74(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x5650
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
jne 0x12c8b
movq -0x20(%rbp), %rdi
callq 0x51f0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x56e0
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5560
cmpl $0x0, -0x7c(%rbp)
jne 0x12c89
leaq -0x68(%rbp), %rdi
callq 0x13ac0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12cac
jmp 0x12c8b
jmp 0x12c8d
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x13b20
movq %rax, -0x88(%rbp)
jmp 0x12bd4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0xe8, %rsi
leaq -0x30(%rbp), %rdi
callq 0xc1e0
leaq -0x30(%rbp), %rdi
callq 0x13c40
testb $0x1, %al
jne 0x12cfa
jmp 0x12d0a
movb $0x1, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x12d96
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x9210
movq -0x78(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x9280
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x13c80
movq %rax, -0x70(%rbp)
jmp 0x12d3f
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9280
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9240
testb $0x1, %al
jne 0x12d67
jmp 0x12d8b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x12d96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8ec0
jmp 0x12dad
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8ec0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0xa0(%rdi)
movq -0x10(%rbp), %rsi
addq $0xa8, %rsi
addq $0xa8, %rdi
callq 0x5050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
addq $0x100, %rdi            # imm = 0x100
callq 0x18840
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
addq $0x130, %rdi            # imm = 0x130
callq 0x18870
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x148, %rsi            # imm = 0x148
addq $0x148, %rdi            # imm = 0x148
callq 0x18ac0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x178, %rsi            # imm = 0x178
addq $0x178, %rdi            # imm = 0x178
callq 0x5050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movb %al, 0x98(%rdi)
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
addq $0x78, %rdi
callq 0x5050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x18dc0
movq -0x10(%rbp), %rdi
callq 0x18da0
movq %rax, %rdi
leaq 0x2ba94(%rip), %rsi     # 0x431db
xorl %eax, %eax
movl %eax, %edx
callq 0x52f0
cmpq $-0x1, %rax
jne 0x177b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x70(%rbp)
callq 0x13ae0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
movl -0x70(%rbp), %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x41890
movl %eax, -0x6c(%rbp)
jmp 0x17788
movl -0x6c(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x18de0
jmp 0x1779d
jmp 0x17734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x178e2
leaq -0x28(%rbp), %rdi
callq 0x18e10
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x18e80
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18e40
testb $0x1, %al
jne 0x177dd
jmp 0x17841
movq -0x10(%rbp), %rdi
callq 0x92b0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x88(%rbp)
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x18f90
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x18eb0
movq %rax, -0x78(%rbp)
jmp 0x17819
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x5050
jmp 0x1782b
jmp 0x1782d
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x18fb0
movq %rax, -0x60(%rbp)
jmp 0x177bd
movq -0x10(%rbp), %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2c10b(%rip), %rsi     # 0x43967
callq 0x9360
movb %al, -0x89(%rbp)
jmp 0x17869
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x17875
jmp 0x178d0
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0x2bbbc(%rip), %rsi     # 0x4344f
callq 0x51d0
jmp 0x1789a
movq -0x98(%rbp), %rdi
movq 0x44748(%rip), %rsi     # 0x5bff0
movq 0x446e9(%rip), %rdx     # 0x5bf98
callq 0x5920
jmp 0x178f4
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x53b0
jmp 0x178e2
leaq -0x28(%rbp), %rdi
callq 0x18ff0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x18ff0
movq -0x40(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18da0
movq %rax, %rdi
leaq 0x2b7f0(%rip), %rsi     # 0x431db
xorl %eax, %eax
movl %eax, %edx
callq 0x52f0
cmpq $-0x1, %rax
je 0x17a4d
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2ba53(%rip), %rsi     # 0x43468
callq 0x51d0
jmp 0x17a1c
movq -0x30(%rbp), %rdi
movq 0x445c9(%rip), %rsi     # 0x5bff0
movq 0x4456a(%rip), %rdx     # 0x5bf98
callq 0x5920
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x53b0
jmp 0x17af3
movq -0x10(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x41890
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2bed5(%rip), %rsi     # 0x43967
callq 0x9360
testb $0x1, %al
jne 0x17a9d
jmp 0x17aed
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x2b9db(%rip), %rsi     # 0x43493
callq 0x51d0
jmp 0x17abf
movq -0x38(%rbp), %rdi
movq 0x44526(%rip), %rsi     # 0x5bff0
movq 0x444c7(%rip), %rdx     # 0x5bf98
callq 0x5920
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x53b0
jmp 0x17af3
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5950
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2c463(%rip), %rsi     # 0x440be
callq 0x8ff0
testb $0x1, %al
jne 0x17c66
jmp 0x17c73
movq -0x28(%rbp), %rax
movb $0x1, 0x98(%rax)
jmp 0x17cf0
movq -0x10(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2c471(%rip), %rsi     # 0x440f7
callq 0x8ff0
testb $0x1, %al
jne 0x17c91
jmp 0x17c9e
movq -0x28(%rbp), %rax
movb $0x0, 0x98(%rax)
jmp 0x17cee
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2b830(%rip), %rsi     # 0x434e9
callq 0x51d0
jmp 0x17cc0
movq -0x30(%rbp), %rdi
movq 0x44325(%rip), %rsi     # 0x5bff0
movq 0x442c6(%rip), %rdx     # 0x5bf98
callq 0x5920
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x53b0
jmp 0x17d6c
jmp 0x17cf0
movq -0x10(%rbp), %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2bc5c(%rip), %rsi     # 0x43967
callq 0x9360
testb $0x1, %al
jne 0x17d16
jmp 0x17d66
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x2b7d5(%rip), %rsi     # 0x43506
callq 0x51d0
jmp 0x17d38
movq -0x38(%rbp), %rdi
movq 0x442ad(%rip), %rsi     # 0x5bff0
movq 0x4424e(%rip), %rdx     # 0x5bf98
callq 0x5920
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x53b0
jmp 0x17d6c
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::cgi(__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::cgi(std::vector<std::string>::iterator &it) {
  std::string &ext = *it++;
  std::string &exec = *it++;
  cgi_[ext] = exec;
  if (*it != ";")
    throw std::runtime_error("triple value in 'cgi'");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x13ae0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x92b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x13ae0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x92b0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x148, %rdi            # imm = 0x148
movq -0x18(%rbp), %rsi
callq 0x19050
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x5050
movq -0x10(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq 0x2ba2c(%rip), %rsi     # 0x43967
callq 0x9360
testb $0x1, %al
jne 0x17f46
jmp 0x17f96
movl $0x10, %edi
callq 0x5250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x2b627(%rip), %rsi     # 0x43588
callq 0x51d0
jmp 0x17f68
movq -0x58(%rbp), %rdi
movq 0x4407d(%rip), %rsi     # 0x5bff0
movq 0x4401e(%rip), %rdx     # 0x5bf98
callq 0x5920
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x53b0
jmp 0x17f9c
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b5e4(%rip), %rsi     # 0x438cb
callq 0x8ff0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x18343
movq -0x8(%rbp), %rdi
leaq 0x2b256(%rip), %rsi     # 0x43559
callq 0x8ff0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x18343
movq -0x8(%rbp), %rdi
leaq 0x2b236(%rip), %rsi     # 0x43555
callq 0x8ff0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x18343
movq -0x8(%rbp), %rdi
leaq 0x2b21d(%rip), %rsi     # 0x43558
callq 0x8ff0
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: solaldunckel[P]webserv/srcs/HTTP/CGI.cpp
// Function: CGI::CGI(File&, RequestConfig&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::comp, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
CGI::CGI(File &file, RequestConfig &config, std::map<std::string, std::string, ft::comp> &req_headers, std::string &req_body) : file_(file), config_(config), req_headers_(req_headers) {
  if (req_body.empty() && config_.getMethod() != "POST")
    req_body_ = file_.getContent();
  else
    req_body_ = req_body;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x98(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x90(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x88(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x80(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x70(%rbp)
callq 0x57b0
movq -0x68(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x356d0
jmp 0x1e80c
movq -0x68(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movq %rdi, -0xa8(%rbp)
callq 0x18820
movq -0x28(%rbp), %rdi
callq 0x5900
testb $0x1, %al
jne 0x1e835
jmp 0x1e8d4
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13030
movq %rax, -0xb0(%rbp)
jmp 0x1e84b
movq -0xb0(%rbp), %rdi
leaq 0x24d45(%rip), %rsi     # 0x4359e
callq 0x9360
movb %al, -0xb1(%rbp)
jmp 0x1e866
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x1e872
jmp 0x1e8d4
movq -0x68(%rbp), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0x37c50
jmp 0x1e884
movq -0x68(%rbp), %rdi
addq $0xd8, %rdi
leaq -0x58(%rbp), %rsi
callq 0x56d0
leaq -0x58(%rbp), %rdi
callq 0x5aa8
jmp 0x1e8ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1e8f5
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xc420
movq -0x60(%rbp), %rdi
callq 0x358f0
jmp 0x1e8f5
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xd8, %rdi
callq 0x5050
jmp 0x1e8ea
jmp 0x1e8ec
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5aa8
movq -0x78(%rbp), %rdi
callq 0x5aa8
movq -0x80(%rbp), %rdi
callq 0x5aa8
movq -0x88(%rbp), %rdi
callq 0x5aa8
movq -0x90(%rbp), %rdi
callq 0x5aa8
movq -0x98(%rbp), %rdi
callq 0x5aa8
movq -0xa0(%rbp), %rdi
callq 0x5aa8
movq -0x30(%rbp), %rdi
callq 0x5950
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x1d0(%rax), %rdi
callq 0x56b0
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rdi
callq 0x56b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c8(%rax)
je 0x1f042
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x422b0
jmp 0x1f040
jmp 0x1f042
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x35960
jmp 0x1f054
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x366f0
jmp 0x1f066
movq -0x10(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xc420
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x358f0
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5aa8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6d40
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x38(%rax)
je 0x21c72
callq 0x423f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x38(%rax), %rdi
callq 0x23970
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
cmpq $0x12c, %rax            # imm = 0x12C
jg 0x21c55
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x38(%rax), %rdi
callq 0x23990
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq $0x96, %rax
jle 0x21c70
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x23910
testb $0x1, %al
jne 0x21c68
jmp 0x21c6e
movb $0x1, -0x1(%rbp)
jmp 0x21c76
jmp 0x21c70
jmp 0x21c72
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x48(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x40(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x20(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x38(%rbp)
callq 0x57b0
movq -0x28(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x30(%rbp)
callq 0x239b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x0, 0xf0(%rax)
movl $0x0, 0xf4(%rax)
movl $0x0, 0x120(%rax)
leaq 0x2185d(%rip), %rsi     # 0x43736
callq 0x5780
jmp 0x21ee0
movq -0x58(%rbp), %rdi
addq $0xf8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x58b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x239d0
movq -0x38(%rbp), %rdi
callq 0x5aa8
movq -0x20(%rbp), %rdi
callq 0x5aa8
movq -0x40(%rbp), %rdi
callq 0x5aa8
movq -0x48(%rbp), %rdi
callq 0x5aa8
movq -0x50(%rbp), %rdi
callq 0x5aa8
movq -0x28(%rbp), %rdi
callq 0x5aa8
movq -0x10(%rbp), %rdi
callq 0x5950
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
addq $0x108, %rdi            # imm = 0x108
xorl %eax, %eax
movl %eax, %esi
callq 0x58b0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5710
movq -0x18(%rbp), %rdi
callq 0x5740
movq -0x28(%rbp), %rax
cmpl $0x0, 0x120(%rax)
jne 0x22032
movq -0x28(%rbp), %rdi
callq 0x22110
cltq
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x120(%rax)
jne 0x2204e
movq -0x28(%rbp), %rdi
callq 0x22590
cltq
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, 0x120(%rax)
jne 0x2206a
movq -0x28(%rbp), %rdi
callq 0x22990
cltq
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, 0x120(%rax)
jne 0x22086
movq -0x28(%rbp), %rdi
callq 0x232b0
cltq
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, 0x120(%rax)
jne 0x220a2
movq -0x28(%rbp), %rdi
callq 0x23360
cltq
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x5, 0x120(%rax)
je 0x220b6
cmpq $0x1, -0x20(%rbp)
jne 0x220cd
movq -0x28(%rbp), %rax
movl $0x5, 0x120(%rax)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x22101
movq -0x28(%rbp), %rax
cmpl $0x6, 0x120(%rax)
je 0x220e1
cmpq $0x1, -0x20(%rbp)
jbe 0x220f8
movq -0x28(%rbp), %rax
movl $0x6, 0x120(%rax)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x22101
jmp 0x220fa
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5830
movq -0x18(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jb 0x2334f
movq -0x18(%rbp), %rdx
movq %rdx, %rdi
addq $0xa0, %rdi
movslq 0xf0(%rdx), %rsi
movq 0x118(%rdx), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x55f0
movq -0x18(%rbp), %rdi
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movslq 0xf0(%rdi), %rax
addq %rcx, %rax
movl %eax, 0xf0(%rdi)
callq 0x5740
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5830
movq -0x18(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jne 0x23346
movl $0x1, -0x4(%rbp)
jmp 0x23356
movl $0x190, -0x4(%rbp)      # imm = 0x190
jmp 0x23356
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop