LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getProduitAvecNomProduit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Produit *Magasin::getProduitAvecNomProduit(std::string nomProduit) {
    Produit *res = nullptr;
    for (Produit *produit : this->listeProduits) {
        if (produit->getTitreProduit() == nomProduit) {
            res = produit;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x18(%rbp)
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb450
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbbc0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbf0
testb $0x1, %al
jne 0x148c5
jmp 0x14919
leaq -0x28(%rbp), %rdi
callq 0xbc30
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x13010
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb350
movb %al, -0x61(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x14904
jmp 0x1490c
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1490e
leaq -0x28(%rbp), %rdi
callq 0xbc50
jmp 0x148b2
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getClientAvecNomPrenomClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Client *Magasin::getClientAvecNomPrenomClient(std::string nomClient, std::string prenomClient) {
    Client *res = nullptr;
    for (Client *client : this->listeClients) {
        if ((client->getNomClient() == nomClient) && (client->getPrenomClient() == prenomClient)) {
            res = client;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x20(%rbp)
addq $0x50, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17180
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x171b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x171e0
testb $0x1, %al
jne 0x14999
jmp 0x14a76
leaq -0x30(%rbp), %rdi
callq 0x17220
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x85f0
movq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xb350
movb %al, %cl
movb $0x0, -0x8d(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x149de
jmp 0x14a0a
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x8590
jmp 0x149ed
movq -0x98(%rbp), %rsi
movb $0x1, -0x8d(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb350
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xa2(%rbp)
testb $0x1, -0x8d(%rbp)
jne 0x14a21
jmp 0x14a2a
leaq -0x80(%rbp), %rdi
callq 0x4200
leaq -0x60(%rbp), %rdi
callq 0x4200
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x14a3f
jmp 0x14a66
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x14a66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4200
jmp 0x14a83
jmp 0x14a68
leaq -0x30(%rbp), %rdi
callq 0x17240
jmp 0x14983
movq -0x20(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4500
nop
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getCommandeAvecIdentifiantCommande(int)
Commande *Magasin::getCommandeAvecIdentifiantCommande(int identifiantCommande) {
    Commande *res = nullptr;
    for (Commande *commande : this->listeCommandes) {
        if (commande->getIdentifiantCommande() == identifiantCommande) {
            res = commande;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x18(%rbp)
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17260
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x172c0
testb $0x1, %al
jne 0x14ae0
jmp 0x14b13
leaq -0x28(%rbp), %rdi
callq 0x17300
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10ac0
cmpl -0xc(%rbp), %eax
jne 0x14b06
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x14b08
leaq -0x28(%rbp), %rdi
callq 0x17320
jmp 0x14acd
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::~Magasin()
Magasin::~Magasin() {
    for (Produit *produit : this->listeProduits) {
        delete produit;
    }
    for (Client *client : this->listeClients) {
        delete client;
    }
    for (Commande *commande : this->listeCommandes) {
        delete commande;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x11fb2(%rip), %rcx     # 0x26bf0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x38, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb450
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbbc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xbbf0
testb $0x1, %al
jne 0x14c7a
jmp 0x14caf
leaq -0x18(%rbp), %rdi
callq 0xbc30
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x14ca2
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14ca4
leaq -0x18(%rbp), %rdi
callq 0xbc50
jmp 0x14c67
movq -0x70(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x17180
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x171b0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x171e0
testb $0x1, %al
jne 0x14ce8
jmp 0x14d1d
leaq -0x38(%rbp), %rdi
callq 0x17220
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x14d10
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14d12
leaq -0x38(%rbp), %rdi
callq 0x17240
jmp 0x14cd5
movq -0x70(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x17260
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x17290
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x172c0
testb $0x1, %al
jne 0x14d56
jmp 0x14d91
leaq -0x58(%rbp), %rdi
callq 0x17300
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x14d84
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14d86
leaq -0x58(%rbp), %rdi
callq 0x17320
jmp 0x14d43
movq -0x70(%rbp), %rdi
addq $0x68, %rdi
callq 0x17380
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
callq 0x173e0
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
callq 0xb150
movq -0x70(%rbp), %rdi
callq 0x19820
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherProduitAvecNom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Magasin::afficherProduitAvecNom(std::string nomProduit) {
    std::cout << "Le produit " << nomProduit << " est :" << std::endl;
    for (Produit *produit : this->listeProduits) {
        if (produit->getTitreProduit() == nomProduit) {
            std::cout << "Le produit est : " << std::endl << *produit << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x11f95(%rip), %rdi     # 0x26fc8
leaq 0x7a04(%rip), %rsi      # 0x1ca3e
callq 0x42c0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
leaq 0x7a78(%rip), %rsi      # 0x1cacd
callq 0x42c0
movq %rax, %rdi
movq 0x11f3c(%rip), %rsi     # 0x26fa0
callq 0x4310
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb450
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbbc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbbf0
testb $0x1, %al
jne 0x150a5
jmp 0x15131
leaq -0x20(%rbp), %rdi
callq 0xbc30
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x13010
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xb350
movb %al, -0x61(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x150e4
jmp 0x15121
movq 0x11edd(%rip), %rdi     # 0x26fc8
leaq 0x793a(%rip), %rsi      # 0x1ca2c
callq 0x42c0
movq %rax, %rdi
movq 0x11e9f(%rip), %rsi     # 0x26fa0
callq 0x4310
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x17470
movq %rax, %rdi
movq 0x11e84(%rip), %rsi     # 0x26fa0
callq 0x4310
jmp 0x15123
leaq -0x20(%rbp), %rdi
callq 0xbc50
jmp 0x1508f
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Magasin::afficherClient(std::string nomClient, std::string prenomClient) {
    std::cout << "Les clients dont le nom est " << nomClient << " est :" << std::endl;
    for (Client *client : this->listeClients) {
        if ((client->getNomClient() == nomClient) && (client->getPrenomClient() == prenomClient)) {
            std::cout << "Le client est : " << std::endl << *client << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x11b81(%rip), %rdi     # 0x26fc8
leaq 0x7628(%rip), %rsi      # 0x1ca76
callq 0x42c0
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
leaq 0x7661(%rip), %rsi      # 0x1cacd
callq 0x42c0
movq %rax, %rdi
movq 0x11b25(%rip), %rsi     # 0x26fa0
callq 0x4310
movq -0x90(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17180
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x171b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x171e0
testb $0x1, %al
jne 0x154bf
jmp 0x155ce
leaq -0x28(%rbp), %rdi
callq 0x17220
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x85f0
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb350
movb %al, %cl
movb $0x0, -0x85(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x15504
jmp 0x15530
movq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x8590
jmp 0x15513
movq -0xa0(%rbp), %rsi
movb $0x1, -0x85(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb350
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xa2(%rbp)
testb $0x1, -0x85(%rbp)
jne 0x15547
jmp 0x15550
leaq -0x78(%rbp), %rdi
callq 0x4200
leaq -0x58(%rbp), %rdi
callq 0x4200
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x15565
jmp 0x155be
movq 0x11a5c(%rip), %rdi     # 0x26fc8
leaq 0x74f2(%rip), %rsi      # 0x1ca65
callq 0x42c0
movq %rax, %rdi
movq 0x11a1e(%rip), %rsi     # 0x26fa0
callq 0x4310
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x17640
movq %rax, %rdi
movq 0x11a03(%rip), %rsi     # 0x26fa0
callq 0x4310
jmp 0x155be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
jmp 0x155d7
jmp 0x155c0
leaq -0x28(%rbp), %rdi
callq 0x17240
jmp 0x154a9
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x4500
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherClient(int)
void Magasin::afficherClient(int identifiantClient) {
    std::cout << "Les clients dont l'identifiant est " << std::to_string(identifiantClient) << " est :" << std::endl;
    for (Client *client : this->listeClients) {
        if (client->getIdentifiantClient() == identifiantClient) {
            std::cout << "Le client est : " << std::endl << *client << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x119c7(%rip), %rdi     # 0x26fc8
leaq 0x748b(%rip), %rsi      # 0x1ca93
callq 0x42c0
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xb9e0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x42b0
movq %rax, -0x68(%rbp)
jmp 0x15634
movq -0x68(%rbp), %rdi
leaq 0x748e(%rip), %rsi      # 0x1cacd
callq 0x42c0
movq %rax, -0x88(%rbp)
jmp 0x1564d
movq -0x88(%rbp), %rdi
movq 0x11945(%rip), %rsi     # 0x26fa0
callq 0x4310
jmp 0x15662
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x80(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x17180
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x171b0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x171e0
testb $0x1, %al
jne 0x156a7
jmp 0x1572b
leaq -0x50(%rbp), %rdi
callq 0x17220
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8550
cmpl -0xc(%rbp), %eax
jne 0x1571b
movq 0x118fc(%rip), %rdi     # 0x26fc8
leaq 0x7392(%rip), %rsi      # 0x1ca65
callq 0x42c0
movq %rax, %rdi
movq 0x118be(%rip), %rsi     # 0x26fa0
callq 0x4310
movq %rax, %rdi
movq -0x60(%rbp), %rsi
callq 0x17640
movq %rax, %rdi
movq 0x118a3(%rip), %rsi     # 0x26fa0
callq 0x4310
jmp 0x1571b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x15734
jmp 0x1571d
leaq -0x50(%rbp), %rdi
callq 0x17240
jmp 0x15691
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4500
nopl (%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherCommandeAvecNom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Magasin::afficherCommandeAvecNom(std::string nomClient, std::string prenomClient) {
    std::cout << "La liste des commandes dont le nom du client est " << nomClient << " est :" << std::endl;
    for (Commande *commande : this->listeCommandes) {
        if (commande->getClientCommande()->getNomClient() == nomClient) {
            std::cout << "La commande est : " << std::endl << *commande << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x110d1(%rip), %rdi     # 0x26fc8
leaq 0x6be9(%rip), %rsi      # 0x1cae7
callq 0x42c0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
leaq 0x6bb4(%rip), %rsi      # 0x1cacd
callq 0x42c0
movq %rax, %rdi
movq 0x11078(%rip), %rsi     # 0x26fa0
callq 0x4310
movq -0x60(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17260
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x172c0
testb $0x1, %al
jne 0x15f69
jmp 0x15ffd
leaq -0x28(%rbp), %rdi
callq 0x17300
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10b00
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x85f0
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb350
movb %al, -0x69(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x15fb0
jmp 0x15fed
movq 0x11011(%rip), %rdi     # 0x26fc8
leaq 0x6b16(%rip), %rsi      # 0x1cad4
callq 0x42c0
movq %rax, %rdi
movq 0x10fd3(%rip), %rsi     # 0x26fa0
callq 0x4310
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x17800
movq %rax, %rdi
movq 0x10fb8(%rip), %rsi     # 0x26fa0
callq 0x4310
jmp 0x15fef
leaq -0x28(%rbp), %rdi
callq 0x17320
jmp 0x15f53
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::initialiserPanierClient(Client*)
void Magasin::initialiserPanierClient(Client *client) {
    std::vector<Produit*> listeProduitsSelectionnesParLeClient;
    for (int i = 0; i < client->getListeNomProduitsSelectionnes().size(); i++) {
        Produit *produit = this->getProduitAvecNomProduit(client->getListeNomProduitsSelectionnes().at(i));
        if (produit) {
            listeProduitsSelectionnesParLeClient.push_back(produit);
        }
        client->initialiserListeProduitSelectionnes(listeProduitsSelectionnesParLeClient);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb030
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x86d0
jmp 0x16058
leaq -0x48(%rbp), %rdi
callq 0xd560
movq %rax, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb090
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0x161be
movq -0x10(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x86d0
jmp 0x1609a
movslq -0x2c(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x17b70
movq %rax, -0xd0(%rbp)
jmp 0x160b3
movq -0xd0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x4150
jmp 0x160c5
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x14870
movq %rax, -0xd8(%rbp)
jmp 0x160de
leaq -0x80(%rbp), %rdi
callq 0x4200
leaq -0x98(%rbp), %rdi
callq 0xb090
movq -0xd8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x16158
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xb1b0
jmp 0x16114
jmp 0x16158
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x161d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1614a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4200
leaq -0x98(%rbp), %rdi
callq 0xb090
jmp 0x161d0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xad60
jmp 0x16175
movq -0xe0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x9010
jmp 0x1618a
leaq -0xb0(%rbp), %rdi
callq 0xb150
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1603e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb150
jmp 0x161d0
leaq -0x28(%rbp), %rdi
callq 0xb150
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xb150
movq -0x50(%rbp), %rdi
callq 0x4500
nopw %cs:(%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::initialiserCompteurClient()
void Magasin::initialiserCompteurClient() {
    int maximumIdentifiantClient = 0;
    for (Client *client : this->listeClients) {
        if (maximumIdentifiantClient < client->getIdentifiantClient()) {
            maximumIdentifiantClient = client->getIdentifiantClient();
        }
    }
    this->compteurClients = maximumIdentifiantClient + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17180
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x171e0
testb $0x1, %al
jne 0x164e0
jmp 0x16521
leaq -0x20(%rbp), %rdi
callq 0x17220
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8550
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x16514
movq -0x30(%rbp), %rdi
callq 0x8550
movl %eax, -0xc(%rbp)
jmp 0x16516
leaq -0x20(%rbp), %rdi
callq 0x17240
jmp 0x164cd
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::initialiserCompteurCommande()
void Magasin::initialiserCompteurCommande() {
    int maximumIdentifiantCommande = 0;
    for (Commande *commande : this->listeCommandes) {
        if (maximumIdentifiantCommande < commande->getIdentifiantCommande()) {
            maximumIdentifiantCommande = commande->getIdentifiantCommande();
        }
    }
    this->compteurCommandes = maximumIdentifiantCommande + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17260
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17290
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x172c0
testb $0x1, %al
jne 0x16590
jmp 0x165d1
leaq -0x20(%rbp), %rdi
callq 0x17300
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10ac0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x165c4
movq -0x30(%rbp), %rdi
callq 0x10ac0
movl %eax, -0xc(%rbp)
jmp 0x165c6
leaq -0x20(%rbp), %rdi
callq 0x17320
jmp 0x1657d
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x84(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pc260533[P]ITC313-TP2/./client.h
// Function: operator<<(std::ostream&, Client const&)
std::ostream& operator<< (std::ostream& out, const Client &client){
        out << client.affichageCourt() << std::endl;
        out << "La liste des produits du panier sont : " << std::endl;
        for (int i = 0; i < client.listeProduitsSelectionnes.size(); i++) {
            out << "Quantite : " << client.listeQuantitesProduitsSelectionnes.at(i) << " " << *client.listeProduitsSelectionnes.at(i);
        }
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x9040
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x42b0
movq %rax, -0x48(%rbp)
jmp 0x1767c
movq -0x48(%rbp), %rdi
movq 0xf919(%rip), %rsi      # 0x26fa0
callq 0x4310
jmp 0x1768e
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x8(%rbp), %rdi
leaq 0x54e6(%rip), %rsi      # 0x1cb88
callq 0x42c0
movq %rax, %rdi
movq 0xf8ef(%rip), %rsi      # 0x26fa0
callq 0x4310
movl $0x0, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0xb250
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x17770
movq -0x8(%rbp), %rdi
leaq 0x54c0(%rip), %rsi      # 0x1cbb0
callq 0x42c0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movslq -0x40(%rbp), %rsi
callq 0x17df0
movq -0x70(%rbp), %rdi
movl (%rax), %esi
callq 0x44f0
movq %rax, %rdi
leaq 0x5452(%rip), %rsi      # 0x1cb74
callq 0x42c0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
movslq -0x40(%rbp), %rsi
callq 0x17e30
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
callq 0x17470
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x176bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x1777a
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4500
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pc260533[P]ITC313-TP2/serializer.cpp
// Function: Serializer::serializeObjetISerializable[abi:cxx11](ISerializable*)
std::string Serializer::serializeObjetISerializable(ISerializable *objetISerializable) {
    std::string objetISerializableSerialize = "";
    try {
        objetISerializableSerialize = objetISerializable->serializerObjet();
    }
    catch (std::exception &exception) {
        throw ExceptionSerialization();
    }
    return objetISerializableSerialize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4510
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x1494(%rip), %rsi      # 0x1cb36
callq 0x7da0
jmp 0x1b6a9
leaq -0x1a(%rbp), %rdi
callq 0x4330
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0x1b6c5
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4380
leaq -0x50(%rbp), %rdi
callq 0x4200
jmp 0x1b783
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4330
jmp 0x1b7ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b7a3
movq -0x28(%rbp), %rdi
callq 0x4130
movq %rax, -0x58(%rbp)
movl $0x8, %edi
callq 0x4190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x1bc00
jmp 0x1b73e
movq -0x78(%rbp), %rdi
leaq 0xb627(%rip), %rsi      # 0x26d70
leaq 0x4f0(%rip), %rdx       # 0x1bc40
callq 0x44d0
jmp 0x1b7bd
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4250
jmp 0x1b77a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x44b0
jmp 0x1b781
jmp 0x1b7a3
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1b796
movq -0x68(%rbp), %rdi
callq 0x4200
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4200
movq -0x28(%rbp), %rdi
callq 0x4500
movq %rax, %rdi
callq 0x7ec0
nopl (%rax)
// File: pc260533[P]ITC313-TP2/serializer.cpp
// Function: Serializer::deserializeObjetISerializable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ISerializable*)
void Serializer::deserializeObjetISerializable(std::string objetISerilizableString, ISerializable *objetISerilizable) {
    try {
        objetISerilizable->deserialiserObjet(ObjetSerialized(objetISerilizableString));
    }
    catch (std::exception &exception) {
        throw ExceptionSerialization();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4150
jmp 0x1b7f0
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x19960
jmp 0x1b802
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
jmp 0x1b818
leaq -0x68(%rbp), %rdi
callq 0x199b0
leaq -0x88(%rbp), %rdi
callq 0x4200
jmp 0x1b91c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1b881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1b875
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x199b0
leaq -0x88(%rbp), %rdi
callq 0x4200
movl -0x94(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b925
movq -0x90(%rbp), %rdi
callq 0x4130
movq %rax, -0xa0(%rbp)
movl $0x8, %edi
callq 0x4190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x1bc00
jmp 0x1b8c5
movq -0xb0(%rbp), %rdi
leaq 0xb49d(%rip), %rsi      # 0x26d70
leaq 0x366(%rip), %rdx       # 0x1bc40
callq 0x44d0
jmp 0x1b939
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x4250
jmp 0x1b913
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x44b0
jmp 0x1b91a
jmp 0x1b925
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x4500
movq %rax, %rdi
callq 0x7ec0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SpaceQuality::SpaceQuality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SpaceQuality::SpaceQuality(const string &nm)

{				// Default space qualities
  name = nm;
  type = ramtype;
  size = 0;
  wordsize = 1;
  isdefault = false;
}

// 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 %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x11700
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11050
jmp 0x5a5a3
movq -0x30(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0x24(%rax)
movl $0x1, 0x28(%rax)
movb $0x0, 0x2c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x11300
movq -0x18(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: FieldQuality::FieldQuality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned long*, unsigned long*)
FieldQuality::FieldQuality(string *nm,uintb *l,uintb *h)

{
  name = *nm;
  low = *l;
  high = *h;
  signext = false;
  flow = true;
  hex = true;
  delete nm;
  delete l;
  delete h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x11700
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11050
jmp 0x5a62b
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movl %ecx, 0x24(%rax)
movb $0x0, 0x28(%rax)
movb $0x1, 0x29(%rax)
movb $0x1, 0x2a(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5a674
movq -0x48(%rbp), %rdi
callq 0x11300
movq -0x48(%rbp), %rdi
movl $0x20, %esi
callq 0x11450
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x5a690
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x5a6ac
movq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x11300
movq -0x28(%rbp), %rdi
callq 0x118b0
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: WithBlock::set(SubtableSymbol*, PatternEquation*, std::vector<ContextChange*, std::allocator<ContextChange*>>*)
void WithBlock::set(SubtableSymbol *s, PatternEquation *pq, vector<ContextChange *> *cvec)

{
  ss = s;
  pateq = pq;
  if (pateq != (PatternEquation *)0)
    pateq->layClaim();
  if (cvec != (vector<ContextChange *> *)0) {
    for(int4 i=0;i<cvec->size();++i)
      contvec.push_back((*cvec)[i]);	// Lay claim to -cvec-s pointers, we don't clone
    delete cvec;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x5a713
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6a230
cmpq $0x0, -0x20(%rbp)
je 0x5a795
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6a250
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5a76e
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6a2e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6a270
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a721
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5a793
movq -0x48(%rbp), %rdi
callq 0x6a300
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0x11450
jmp 0x5a795
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: WithBlock::~WithBlock()
WithBlock::~WithBlock(void)

{
  if (pateq != (PatternEquation *)0)
    PatternEquation::release(pateq);
  for(int4 i=0;i<contvec.size();++i) {
    delete contvec[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x5a7cc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8c930
jmp 0x5a7ca
jmp 0x5a7cc
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x6a250
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x5a829
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6a2e0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5a81c
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5a81e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a7d3
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x6a300
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x15590
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: WithBlock::collectAndPrependPattern(std::__cxx11::list<WithBlock, std::allocator<WithBlock>> const&, PatternEquation*)
PatternEquation *WithBlock::collectAndPrependPattern(const list<WithBlock> &stack, PatternEquation *pateq)

{
  list<WithBlock>::const_iterator iter;
  for(iter=stack.begin();iter!=stack.end();++iter) {
    PatternEquation *witheq = (*iter).pateq;
    if (witheq != (PatternEquation *)0)
      pateq = new EquationAnd(witheq, pateq);
  }
  return pateq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6a360
movq -0x8(%rbp), %rdi
callq 0x6a380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a3e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6a3b0
testb $0x1, %al
jne 0x5a89e
jmp 0x5a90f
leaq -0x18(%rbp), %rdi
callq 0x6a410
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5a8ff
movl $0x48, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x8e8e0
jmp 0x5a8d9
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a8ff
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x48, %esi
callq 0x11450
jmp 0x5a919
jmp 0x5a901
leaq -0x18(%rbp), %rdi
callq 0x6a440
jmp 0x5a87e
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: WithBlock::getCurrentSubtable(std::__cxx11::list<WithBlock, std::allocator<WithBlock>> const&)
SubtableSymbol *WithBlock::getCurrentSubtable(const list<WithBlock> &stack)

{
  list<WithBlock>::const_iterator iter;
  for(iter=stack.begin();iter!=stack.end();++iter) {
    if ((*iter).ss != (SubtableSymbol *)0)
      return (*iter).ss;
  }
  return (SubtableSymbol *)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6a360
movq -0x10(%rbp), %rdi
callq 0x6a380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a3e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6a3b0
testb $0x1, %al
jne 0x5ab8a
jmp 0x5abb8
leaq -0x18(%rbp), %rdi
callq 0x6a410
cmpq $0x0, (%rax)
je 0x5abab
leaq -0x18(%rbp), %rdi
callq 0x6a410
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5abc0
jmp 0x5abad
leaq -0x18(%rbp), %rdi
callq 0x6a440
jmp 0x5ab6a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::ConsistencyChecker(SubtableSymbol*, bool, bool)
ConsistencyChecker::ConsistencyChecker(SubtableSymbol *rt,bool un,bool warndead)

{
  root_symbol = rt;
  unnecessarypcode = 0;
  readnowrite = 0;
  writenoread = 0;
  printextwarning = un;
  printdeadwarning = warndead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x6a4d0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x6a4f0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xc(%rax)
movb -0x12(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xd(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::dealWithUnnecessaryExt(OpTpl*, Constructor*)
void ConsistencyChecker::dealWithUnnecessaryExt(OpTpl *op,Constructor *ct)

{ // Deal with detected extension (SEXT or ZEXT) where the
  // input size is the same as the output size
  if (printextwarning) {
    cerr << "Unnecessary ";
    printOpName(cerr,op);
    cerr << " in constructor starting at line " << dec << ct->getLineno() << endl;
  }
  op->setOpcode(CPUI_COPY);	// Equivalent to copy
  unnecessarypcode += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xc(%rax)
je 0x5b0c2
movq 0xd6f8f(%rip), %rdi     # 0x131fe8
leaq 0x7da5d(%rip), %rsi     # 0xd8abd
callq 0x11420
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq 0xd6f74(%rip), %rsi     # 0x131fe8
callq 0x5b0f0
movq 0xd6f68(%rip), %rdi     # 0x131fe8
leaq 0x7e073(%rip), %rsi     # 0xd90fa
callq 0x11420
movq %rax, %rdi
leaq -0x35a26(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a600
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
movq 0xd6ee3(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6a620
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::dealWithUnnecessaryTrunc(OpTpl*, Constructor*)
void ConsistencyChecker::dealWithUnnecessaryTrunc(OpTpl *op,Constructor *ct)

{
  if (printextwarning) {
    cerr << "Unnecessary ";
    printOpName(cerr,op);
    cerr << " in constructor starting at line " << dec << ct->getLineno() << endl;
  }
  op->setOpcode(CPUI_COPY);	// Equivalent to copy
  op->removeInput(1);
  unnecessarypcode += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xc(%rax)
je 0x5b702
movq 0xd694f(%rip), %rdi     # 0x131fe8
leaq 0x7d41d(%rip), %rsi     # 0xd8abd
callq 0x11420
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq 0xd6934(%rip), %rsi     # 0x131fe8
callq 0x5b0f0
movq 0xd6928(%rip), %rdi     # 0x131fe8
leaq 0x7da33(%rip), %rsi     # 0xd90fa
callq 0x11420
movq %rax, %rdi
leaq -0x36066(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a600
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
movq 0xd68a3(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6a620
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4c8d0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::checkOpMisuse(OpTpl*, Constructor*)
bool ConsistencyChecker::checkOpMisuse(OpTpl *op,Constructor *ct)

{
  switch(op->getOpcode()) {
  case CPUI_INT_LESS:
    {
      VarnodeTpl *vn = op->getIn(1);
      if (vn->getSpace().isConstSpace() && vn->getOffset().isZero()) {
	cerr << "Unsigned comparison with zero is always false in constructor starting at line " << dec << ct->getLineno() << endl;
      }
    }
    break;
  default:
    break;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fd40
subl $0xf, %eax
jne 0x5b7e3
jmp 0x5b758
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3fce0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40220
movq %rax, %rdi
callq 0x49fb0
testb $0x1, %al
jne 0x5b781
jmp 0x5b7e1
movq -0x20(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x40c90
testb $0x1, %al
jne 0x5b798
jmp 0x5b7e1
movq 0xd6849(%rip), %rdi     # 0x131fe8
leaq 0x7d324(%rip), %rsi     # 0xd8aca
callq 0x11420
movq %rax, %rdi
leaq -0x36145(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a600
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
movq 0xd67c4(%rip), %rsi     # 0x131fa0
callq 0x114a0
jmp 0x5b7e5
jmp 0x5b7e5
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::getOperandSymbol(int, OpTpl*, Constructor*)
OperandSymbol *ConsistencyChecker::getOperandSymbol(int4 slot,OpTpl *op,Constructor *ct)

{
  VarnodeTpl *vn;
  OperandSymbol *opsym;
  int4 handindex;

  if (slot == -1)
    vn = op->getOut();
  else
    vn = op->getIn(slot);
  
  switch(vn->getSize().getType()) {
  case ConstTpl::handle:
    handindex = vn->getSize().getHandleIndex();
    opsym = ct->getOperand(handindex);
    break;
  default:
    opsym = (OperandSymbol *)0;
    break;
  }
  return opsym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x5df9c
movq -0x18(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x28(%rbp)
jmp 0x5dfac
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3fce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3fbf0
movq %rax, %rdi
callq 0x3fc10
subl $0x1, %eax
jne 0x5dfea
jmp 0x5dfc4
movq -0x28(%rbp), %rdi
callq 0x3fbf0
movq %rax, %rdi
callq 0x402b0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x179c0
movq %rax, -0x30(%rbp)
jmp 0x5dff2
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::checkConstructorSection(Constructor*, ConstructTpl*)
bool ConsistencyChecker::checkConstructorSection(Constructor *ct,ConstructTpl *cttpl)

{ // Check all the OpTpl s within the given section for consistency, return true if all tests pass
  if (cttpl == (ConstructTpl *)0)
    return true;		// Nothing to check
  vector<OpTpl *>::const_iterator iter;
  const vector<OpTpl *> &ops(cttpl->getOpvec());
  bool testresult = true;

  for(iter=ops.begin();iter!=ops.end();++iter) {
    if (!sizeRestriction(*iter,ct))
      testresult = false;
    if (!checkOpMisuse(*iter,ct))
      testresult = false;
  }
  return testresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5e02c
movb $0x1, -0x1(%rbp)
jmp 0x5e0d2
leaq -0x28(%rbp), %rdi
callq 0x3fd60
movq -0x20(%rbp), %rdi
callq 0x3fd80
movq %rax, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3fda0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3fe10
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3fdd0
testb $0x1, %al
jne 0x5e07b
jmp 0x5e0ca
leaq -0x28(%rbp), %rdi
callq 0x3fe40
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x5b7f0
testb $0x1, %al
jne 0x5e09c
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3fe40
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x5b730
testb $0x1, %al
jne 0x5e0bd
movb $0x0, -0x31(%rbp)
jmp 0x5e0bf
leaq -0x28(%rbp), %rdi
callq 0x3fe60
jmp 0x5e05b
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::checkSectionTruncations(Constructor*, ConstructTpl*, bool)
bool ConsistencyChecker::checkSectionTruncations(Constructor *ct,ConstructTpl *cttpl,bool isbigendian)

{ // Check all the varnodes that have an offset_plus template
  //     adjust the plus if we are bigendian
  //     make sure the truncation is valid
  vector<OpTpl *>::const_iterator iter;
  const vector<OpTpl *> &ops(cttpl->getOpvec());
  bool testresult = true;
  
  for(iter=ops.begin();iter!=ops.end();++iter) {
    OpTpl *op = *iter;
    VarnodeTpl *outvn = op->getOut();
    if (outvn != (VarnodeTpl *)0) {
      if (!checkVarnodeTruncation(ct,-1,op,outvn,isbigendian))
	testresult = false;
    }
    for(int4 i=0;i<op->numInput();++i) {
      if (!checkVarnodeTruncation(ct,i,op,op->getIn(i),isbigendian))
	testresult = false;
    }
  }
  return testresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3fd60
movq -0x18(%rbp), %rdi
callq 0x3fd80
movq %rax, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3fda0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3fe10
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3fdd0
testb $0x1, %al
jne 0x5e4d8
jmp 0x5e5b5
leaq -0x28(%rbp), %rdi
callq 0x3fe40
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x5e529
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %r8
movb -0x19(%rbp), %al
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
andb $0x1, %al
movzbl %al, %r9d
callq 0x5e0e0
testb $0x1, %al
jne 0x5e527
movb $0x0, -0x31(%rbp)
jmp 0x5e529
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3fcc0
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5e5a5
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x3fce0
movq -0x68(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %edx
movq -0x78(%rbp), %rcx
movq %rax, %r8
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x5e0e0
testb $0x1, %al
jne 0x5e598
movb $0x0, -0x31(%rbp)
jmp 0x5e59a
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x5e530
jmp 0x5e5a7
leaq -0x28(%rbp), %rdi
callq 0x3fe60
jmp 0x5e4b5
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)