diff --git a/MANIFEST.in b/MANIFEST.in
index a9e1a081..1ad2a0de 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,5 +1,6 @@
 prune media
 prune test
 prune docs
+prune examples
 prune .github
 prune */__pycache__
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 6326b8fe..adc39e57 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -14,7 +14,7 @@
 project = 'libdebug'
 copyright = '2024, Gabriele Digregorio, Roberto Alessandro Bertolini, Francesco Panebianco'
 author = 'JinBlack, Io_no, MrIndeciso, Frank01001'
-release = '0.5.3'
+release = '0.5.4'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
diff --git a/docs/source/logging.rst b/docs/source/logging.rst
index 4714dbbe..88b0bce9 100644
--- a/docs/source/logging.rst
+++ b/docs/source/logging.rst
@@ -29,13 +29,39 @@ The best of both worlds
 -----------------------
 The `dbg` option is the combination of the `pipe` and `debugger` options. It displays all logs related to the debugging operations performed on the process by libdebug, as well as interactions with the process pipe: bytes received and bytes sent.
 
-Temporary Logging
------------------
+Change logger levels at runtime
+-------------------------------
+Logger levels can be changed at runtime using the `libcontext` module. The following example shows how to change the logger levels at runtime.
+
+.. code-block:: python
+
+    from libdebug import libcontext
+    libcontext.pipe_logger = 'DEBUG'
+    libcontext.debugger_logger = 'DEBUG'
+    libcontext.general_logger = 'DEBUG'
+
+The `general_logger` refers to the logger used for the general logs, different from the `pipe` and `debugger` logs.
 
 Logger levels can be temporarily enabled at runtime using a `with` statement, as shown in the following example.
 
 .. code-block:: python
 
     from libdebug import libcontext
-    with libcontext.tmp(pipe_logger='INFO', debugger_logger='DEBUG'):
-        r.sendline(b'gimme the flag')
\ No newline at end of file
+    with libcontext.tmp(pipe_logger='SILENT', debugger_logger='DEBUG'):
+        r.sendline(b'gimme the flag')
+
+In this example, the `pipe_logger` is set to `SILENT`, and the `debugger_logger` is set to `DEBUG`. The logger levels are restored to their previous values when the `with` block is exited.
+
+The supported logger levels are the following:
+
+- ``pipe_logger``: ``DEBUG``, ``SILENT``
+- ``debugger_logger``: ``DEBUG``, ``SILENT``
+- ``general_logger``: ``DEBUG``, ``INFO``, ``WARNING``, ``SILENT``
+
+The default logger levels are:
+
+- ``pipe_logger``: ``SILENT``
+- ``debugger_logger``: ``SILENT``
+- ``general_logger``: ``DEBUG``
+
+The `DEBUG` level is the most verbose, including all logs. The `INFO` level includes all logs except for the `DEBUG` logs. The `WARNING` level includes only the `WARNING` logs. The `SILENT` level disables all logs.
\ No newline at end of file
diff --git a/examples/bof_detection/bof b/examples/bof_detection/bof
new file mode 100755
index 00000000..5506074a
Binary files /dev/null and b/examples/bof_detection/bof differ
diff --git a/examples/bof_detection/bof.c b/examples/bof_detection/bof.c
new file mode 100644
index 00000000..f7354067
--- /dev/null
+++ b/examples/bof_detection/bof.c
@@ -0,0 +1,25 @@
+//
+// This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+// Copyright (c) 2024 Francesco Panebianco. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+// Compile with:
+// gcc bof.c -o bof -fno-stack-protector -std=c99
+
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+    char buffer[32];
+    
+    // Setvbuf is used to disable buffering
+    setvbuf(stdin, NULL, _IONBF, 0);
+    setvbuf(stdout, NULL, _IONBF, 0);
+    
+    printf("libdebug 4 exploitation testing bench\n");
+
+    printf("Enter a string: ");
+    // This is a vulnerable function, it does not check the size of the input
+    gets(buffer);
+
+    return 0;
+}
diff --git a/examples/bof_detection/detect_bof.py b/examples/bof_detection/detect_bof.py
new file mode 100644
index 00000000..ef38779c
--- /dev/null
+++ b/examples/bof_detection/detect_bof.py
@@ -0,0 +1,349 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Francesco Panebianco. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+from libdebug import debugger, libcontext
+from libdebug.utils.debugging_utils import resolve_address_in_maps
+import iced_x86 as iced
+import argparse
+import os
+import magic
+
+libcontext.sym_lvl = 5
+
+###########################################
+# -------- Linux Terminal Colors -------- #
+###########################################
+LT_COLOR_RED = "31"
+LT_COLOR_GREEN = "32"
+LT_COLOR_YELLOW = "33"
+LT_COLOR_BLUE = "34"
+LT_COLOR_MAGENTA = "35"
+LT_COLOR_CYAN = "36"
+LT_COLOR_WHITE = "37"
+LT_COLOR_DEFAULT = "39"
+
+
+#######################################
+# -------- Utility Functions -------- #
+#######################################
+
+def p64(in_bytes):
+    return in_bytes.to_bytes(8, byteorder='little')
+
+def p32(in_bytes):
+    return in_bytes.to_bytes(4, byteorder='little')
+
+def p16(in_bytes):
+    return in_bytes.to_bytes(2, byteorder='little')
+
+def p8(in_bytes):
+    return in_bytes.to_bytes(1, byteorder='little')
+
+def u64(in_bytes):
+    return int.from_bytes(in_bytes, byteorder='little')
+
+def u32(in_bytes):
+    return int.from_bytes(in_bytes, byteorder='little')
+
+def u16(in_bytes):
+    return int.from_bytes(in_bytes, byteorder='little')
+
+def u8(in_bytes):
+    return int.from_bytes(in_bytes, byteorder='little')
+
+def print_color(message, color, end='\n'):
+    print(f"\033[{color}m{message}\033[0m", end=end)
+
+has_crashed = False
+rip_overwritten = False
+rbp_overwritten = False
+canary_overwritten = False
+fortify_failed = False
+
+# Constants
+MAX_AMD64_INSTRUCTION_LENGTH = 15
+MAX_TEST_LEN = 128
+
+##########################################
+# ----------- Initialization ----------- #
+##########################################
+
+# Initialize a formatter
+formatter = iced.Formatter(iced.FormatterSyntax.INTEL)
+
+# Assumption: Input is given from stdin instead of a file or a command line argument
+# Different scenarios can easily be handled by changing the input source
+
+# Create the parser
+parser = argparse.ArgumentParser(description='Find vulnerabilities in an AMD64 Linux ELF')
+
+# Add the --maxlen argument
+parser.add_argument('--maxlen', type=int, help='maximum length of the input to test')
+
+# Add the positional argument for the file name
+parser.add_argument('filename', type=str, help='the path to the file to process')
+
+# Parse the arguments
+args = parser.parse_args()
+
+# Print the arguments
+print(f'File name: {args.filename}')
+if args.maxlen is not None:
+    print(f'Max length: {args.maxlen}')
+
+# Get the ELF file
+ELF_PATH = args.filename
+MAX_TEST_LEN = args.maxlen if args.maxlen is not None else MAX_TEST_LEN
+
+# Check if the ELF file exists and is valid
+if not os.path.exists(ELF_PATH):
+    print(f"File {ELF_PATH} does not exist.")
+    exit(1)
+elif not os.access(ELF_PATH, os.R_OK):
+    print(f"File {ELF_PATH} is not readable.")
+    exit(1)
+elif 'ELF 64-bit LSB pie executable, x86-64' not in magic.from_file(ELF_PATH):
+    print(f"File {ELF_PATH} is not a 64-bit ELF file.")
+    exit(1)
+
+#########################################
+# ------ Step 1 - "Fuzz" the ELF ------ #
+#########################################
+
+for test_padding_len in range(0, MAX_TEST_LEN, 4):
+    print(f"[+] Testing payload length {test_padding_len}...")
+
+    d = debugger(ELF_PATH)
+
+    test_payload = b'A' * test_padding_len
+
+    pipe = d.run()
+
+    # Break on check stack canary and fortify fail
+    check_stack_fail_br = d.breakpoint('__stack_chk_fail', file='libc.so.6')
+    check_fortify_fail_br = d.breakpoint('__fortify_fail', file='libc.so.6')
+
+    # Catch SIGSEGV and SIGABRT
+    sig1_hdlr = d.catch_signal(signal='SIGSEGV')
+    sig2_hdlr = d.catch_signal(signal='SIGABRT')
+
+    d.cont()
+
+    pipe.sendline(test_payload)
+
+    d.wait()
+
+    if sig1_hdlr.hit_on(d):
+        print(">> Crashed with payload: ", test_payload)
+        print_color(f">> Received signal: SIGSEGV", color=LT_COLOR_RED)
+        has_crashed = True
+    elif sig2_hdlr.hit_on(d):
+        print(">> Crashed with payload: ", test_payload)
+        print_color(f">> Received signal: SIGABRT", color=LT_COLOR_RED)
+        has_crashed = True
+    elif check_stack_fail_br.hit_on(d):
+        print(">> Crashed with payload: ", test_payload)
+        print_color(f">> Stack Canary check failed", color=LT_COLOR_RED)
+        has_crashed = True
+        canary_overwritten = True
+    elif check_fortify_fail_br.hit_on(d):
+        print(">> Crashed with payload: ", test_payload)
+        print_color(f">> Fortify check failed", color=LT_COLOR_RED)
+        has_crashed = True
+        fortify_failed = True
+
+    if has_crashed:
+        print_color(f"[+] Crash detected with payload length {test_padding_len}", color=LT_COLOR_YELLOW)
+        print_color('[+] Post-mortem analysis initiated', color=LT_COLOR_YELLOW)
+
+        curr_rip = d.regs.rip
+
+        # Check for RIP overwrite
+        if '4141' in hex(d.regs.rip):
+            print_color("--> RIP is overwritten with AAAA <--", color=LT_COLOR_RED)
+            rip_overwritten = True
+        else:
+            print(f"RIP is at {hex(curr_rip)}")
+            print("Disassembling the instruction at RIP...")
+
+            # Dump instruction at rip
+            window_from_rip = d.memory[curr_rip, MAX_AMD64_INSTRUCTION_LENGTH, 'absolute']
+
+            # Disassemble the instruction (ignoring bytes that are not part of the instruction)
+            decoder = iced.Decoder(64, window_from_rip)
+            decoder.ip = curr_rip
+
+            instruction = decoder.decode()
+
+            # Get the instruction bytes and convert to hex bytes separated by spaces
+            instruction_bytes = window_from_rip[:instruction.len]
+            instruction_bytes_str = " ".join(f"{b:02X}" for b in instruction_bytes)
+
+            # If the current rip corresponds to a known symbol, print the symbol
+            try:
+                symbol = resolve_address_in_maps(curr_rip, d.maps())
+
+                if not symbol.startswith("0x"):
+                    print_color(f"<{symbol}> ", color=LT_COLOR_CYAN, end="")
+            except ValueError:
+                pass
+
+            # Decode and print each instruction
+            asm = formatter.format(instruction)
+            print_color(f"{hex(instruction.ip)}: {instruction_bytes_str.ljust(2*4, ' ')} | {asm}", color=LT_COLOR_CYAN)
+        
+        # Check for RBP overwrite
+        if not rip_overwritten and '4141' in hex(d.regs.rbp):
+            print_color("--> RBP is overwritten with AAAA <--", color=LT_COLOR_RED)
+            print_color("Stack pivot detected", color=LT_COLOR_RED)
+            rbp_overwritten = True
+        else:
+            print(f"RBP is at {hex(d.regs.rbp)}")
+
+        # Shut up the warnings
+        libcontext.general_logger = 'SILENT'
+        
+        # Stack trace
+        print_color('\nStack trace:', color=LT_COLOR_RED)
+        d.print_backtrace()
+
+    d.kill()
+    d.terminate()
+    print()
+
+    # We found the input to inspect, but let's see if we find also a way to control RIP
+    if has_crashed and rip_overwritten:
+        break
+
+if not has_crashed:
+    print_color("[+] No crash detected. Exiting", color=LT_COLOR_GREEN)
+    exit(0)
+
+if canary_overwritten:
+    print_color("[+] Stack canary overwritten", color=LT_COLOR_YELLOW)
+    print_color("[+] It is possible that an exploit is feasible given a leak of the canary", color=LT_COLOR_YELLOW)
+    exit(0)
+
+if fortify_failed:
+    print_color("[+] Fortify check failed", color=LT_COLOR_YELLOW)
+    print_color("[+] This mitigation can prevent a lot of exploits, but some workarounds are possible", color=LT_COLOR_YELLOW)
+    exit(0)
+
+if not rip_overwritten:
+    print_color("[+] RIP is not overwritten", color=LT_COLOR_YELLOW)
+
+    if rbp_overwritten:
+        print_color("[+] However, the analyzer was able to detect a stack pivot", color=LT_COLOR_YELLOW)
+        print_color("[+] Given a leak, we could use the stack pivot take control of the execution", color=LT_COLOR_YELLOW)
+
+    exit(0)
+
+# If we reach this point, we have a crash and RIP is overwritten
+# We can now proceed to the part where we check which part of the input is used to overwrite RIP
+
+print('\n-----------------------------------\n\n')
+
+print("[+] A payload length that overwrites RIP has been found.")
+print("[+] Starting taint analysis to find the setup.")
+
+#########################################
+# ------ Step 2 - Taint Analysis ------ #
+#########################################
+
+has_found_setup = False
+taint_offset = -1
+
+for taint_start_index in range(0, test_padding_len + 8, 8):
+    taint_end_index = taint_start_index + 8
+
+    TAINT = p64(0xdeadc0de)
+
+    print(f"[+] Analyzing taint from {taint_start_index} to {taint_end_index}...")
+
+    test_payload = b'A' * taint_start_index + TAINT + b'A' * (test_padding_len - taint_end_index) 
+
+    print(f">> Testing payload: {test_payload}")
+
+    d = debugger('bof')
+
+    pipe = d.run()
+
+    sigsegv_checker = d.catch_signal(signal='SIGSEGV')
+
+    d.cont()
+
+    pipe.sendline(test_payload)
+    
+    d.wait()
+
+    if sigsegv_checker.hit_on(d):
+        # Search registers for traces of the taint
+        print_color("Received SIGSEGV", color=LT_COLOR_RED)
+
+        # Dump registers
+        print_color("Registers:", color=LT_COLOR_RED)
+        print_color(f"RAX: {hex(d.regs.rax)}", color=LT_COLOR_RED)
+        print_color(f"RBX: {hex(d.regs.rbx)}", color=LT_COLOR_RED)
+        print_color(f"RCX: {hex(d.regs.rcx)}", color=LT_COLOR_RED)
+        print_color(f"RDX: {hex(d.regs.rdx)}", color=LT_COLOR_RED)
+        print_color(f"RDI: {hex(d.regs.rdi)}", color=LT_COLOR_RED)
+        print_color(f"RSI: {hex(d.regs.rsi)}", color=LT_COLOR_RED)
+        print_color(f"RBP: {hex(d.regs.rbp)}", color=LT_COLOR_RED)
+        print_color(f"RSP: {hex(d.regs.rsp)}", color=LT_COLOR_RED)
+        print_color(f"RIP: {hex(d.regs.rip)}", color=LT_COLOR_RED)
+
+        # Say if any of the registers contain the taint
+        if d.regs.rax == u64(TAINT):
+            print("RAX contains the taint.")
+        if d.regs.rbx == u64(TAINT):
+            print("RBX contains the taint.")
+        if d.regs.rcx == u64(TAINT):
+            print("RCX contains the taint.")
+        if d.regs.rdx == u64(TAINT):
+            print("RDX contains the taint.")
+        if d.regs.rdi == u64(TAINT):
+            print("RDI contains the taint.")
+        if d.regs.rsi == u64(TAINT):
+            print("RSI contains the taint.")
+        if d.regs.rbp == u64(TAINT):
+            print("RBP contains the taint.")
+        if d.regs.rsp == u64(TAINT):
+            print("RSP contains the taint.")
+        if d.regs.rip == u64(TAINT):
+            print("RIP contains the taint.")
+            has_found_setup = True
+            taint_offset = taint_start_index
+            break
+
+        # Searching memory for the taint
+        print("Searching memory for the taint...")
+
+        for map in d.maps():
+            # Skip non-writable maps (e.g., vsyscall)
+            if 'w' not in map.permissions:
+                continue
+            
+            pid = d.threads[0].process_id
+            
+            with open(f'/proc/{pid}/mem', 'rb', 0) as mem:
+                mem.seek(map.start)
+                memory_content = mem.read(map.end - map.start)
+
+                if TAINT in memory_content:
+                    print_color(f">> Taint found in {map.backing_file} at address {hex(map.start + memory_content.index(TAINT))}", color=LT_COLOR_RED)
+    elif d.dead:
+        print(f">>  Program exited with code {d.exit_code} and signal {d.exit_signal}")
+                
+    d.kill()
+    d.terminate()
+
+if not has_found_setup:
+    print_color("[+] No setup found. Exiting...", color=LT_COLOR_GREEN)
+    exit(0)
+
+print_color(f"[+] Found setup at offset {taint_offset}", color=LT_COLOR_CYAN)
+print_color("[+] This vulnerability can be exploited on systems with Intel CET disabled", color=LT_COLOR_CYAN)
+
+# Future expansion: proxy the output to check for useful leaks (e.g, libc addresses, stack addresses, etc.)
\ No newline at end of file
diff --git a/examples/bof_detection/usage.txt b/examples/bof_detection/usage.txt
new file mode 100644
index 00000000..f4ebbc75
--- /dev/null
+++ b/examples/bof_detection/usage.txt
@@ -0,0 +1,2 @@
+To run this use case, write
+$ python detect_bof.py --maxlen 128 bof
\ No newline at end of file
diff --git a/examples/codecov/coverage.py b/examples/codecov/coverage.py
new file mode 100644
index 00000000..fb4ee600
--- /dev/null
+++ b/examples/codecov/coverage.py
@@ -0,0 +1,284 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+# The following example demonstrates how libdebug can be used, in conjunction with
+# other libraries, to efficiently perform unit testing and code coverage analysis on
+# a compiled executable.
+
+import base64
+import capstone
+import libdebug
+import pwn
+
+
+# We use pwntools to load the binary and extract the function we want to test
+# This can be performed manually using pyelftools or similar libraries
+main = pwn.ELF("./main", checksec=False)
+function_name = "long_from_base64_decimal_str"
+function = main.functions[function_name]
+function_asm = main.read(function.address, function.size)
+
+
+# This function uses the Capstone disassembler to find all branches in a specific function
+# It does so by looking for all conditional jumps (jcc) and computing the target address
+# It is not perfect, as some binaries may use register-based jumps, or other more complex
+# control flow structures, but it works well for most cases
+def detect_function_branches(function_asm: str) -> list:
+    """Find all branches in a function."""
+    md = capstone.Cs(capstone.CS_ARCH_X86, capstone.CS_MODE_64)
+    md.detail = True
+    branches = set()
+    for i in md.disasm(function_asm, function.address):
+        if i.mnemonic.startswith("j") and i.mnemonic != "jmp":
+            try:
+                branches.add((i.address, i.operands[0].imm, i.address + i.size))
+            except:
+                print(f"Failed to parse branch at {hex(i.address)}")
+
+    return branches
+
+
+branches = detect_function_branches(function_asm)
+
+
+# This function sets up a debugger instance, as provided by libdebug, and sets up
+# breakpoints on all branches detected in the function. It returns the debugger,
+# along with the pipe to the target process and a list of breakpoints set.
+def setup_debugger():
+    """Setup the debugger."""
+    def empty_callback(_, __): pass
+
+    debugger = libdebug.debugger("main")
+    pipe = debugger.run()
+    breakpoints = []
+    for b in branches:
+        bp_conditional = debugger.breakpoint(b[0], callback=empty_callback)
+        bp_target = debugger.breakpoint(b[1], callback=empty_callback)
+        bp_non_hit = debugger.breakpoint(b[2], callback=empty_callback)
+        breakpoints.append((bp_conditional, bp_target, bp_non_hit))
+
+    return (debugger, pipe, breakpoints)
+
+
+# We use a global variable to store the coverage information
+# This is a dictionary where the key is the branch address and the value is a set
+# containing two elements: whether the conditional branch was hit and whether the
+# target branch was not hit. This allows us to calculate the coverage of the function
+# by counting the number of branches that were hit.
+coverage = {branch[1]: set() for branch in branches}
+
+
+# This function is used to register the coverage information for a specific set of breakpoints
+# It iterates over all breakpoints and checks whether the conditional branch was hit and whether
+# the target branch was not hit. It then updates the coverage dictionary accordingly.
+def register_coverage(bps):
+    for bp in bps:
+        # Check that we hit a conditional jump instruction
+        if bp[0].hit_count > 0:
+            # Check that the took the jump
+            coverage[bp[1].address].add(bp[1].hit_count > 0)
+            # Check that we did not take the jump
+            coverage[bp[1].address].add(bp[2].hit_count == 0)
+
+# This function calculates the coverage of the function by counting the number of branches
+# that were hit. It does so by summing the number of branches that were hit and dividing
+# by the total number of branches.
+def calculate_coverage():
+    covered = sum(len(coverage[branch]) for branch in coverage)
+    total = len(coverage) * 2
+    return covered / total
+
+
+def test_correct_input():
+    number = base64.b64encode(b"1234567890")
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"1234567890"
+    debugger.terminate()
+
+def test_empty_string():
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(b"")
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_invalid_length_base64():
+    number = base64.b64encode(b"1234567890")[:-1]
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_invalid_base64_characters():
+    number = base64.b64encode(b"1234567890")[:-1] + b"\xf0"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_out_of_range_base64_characters_1():
+    number = b"::::"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_out_of_range_base64_characters_2():
+    number = b"!!!!"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_out_of_range_base64_characters_3():
+    number = b"//++"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"0"
+    debugger.terminate()
+
+def test_out_of_range_base64_characters_4():
+    number = b"{{}}"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_out_of_range_base64_characters_5():
+    number = b"\x1f\x1f\x1f\x1f"
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+# This test validates that the function correctly handles null input
+# This is a tricky condition to hit, as the compiled binary will not
+# pass a null pointer to the function, but we can manually set the
+# rdi register to 0 to simulate this condition and check that the
+# function correctly handles it.
+def test_null_input():
+    number = base64.b64encode(b"1234567890")
+    debugger, pipe, breakpoints = setup_debugger()
+
+    # Set an additional breakpoint at the beginning of the function to test
+    debugger.breakpoint("long_from_base64_decimal_str")
+
+    debugger.cont()
+    pipe.sendline(number)
+
+    # We are in the prologue of the function, set the first argument to 0
+    # to simulate a null pointer being passed
+    debugger.regs.rdi = 0
+
+    debugger.cont()
+    pipe.recvline()
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+# This test validates that the function correctly handles a malloc failure
+# We can simulate this condition by setting the size of the allocation to
+# the maximum value of a 64-bit integer, which will cause the malloc function
+# to fail and return NULL. We can then check that the function correctly handles
+# this condition and returns an error message.
+def test_malloc_failure():
+    number = base64.b64encode(b"1234567890")
+    debugger, pipe, breakpoints = setup_debugger()
+
+    # Set a breakpoint on malloc and simulate a failure
+    def bad_malloc(t, _):
+        # Make the malloc call fail if we are trying to allocate the input string
+        if t.regs.rdi == len(number):
+            t.regs.rdi = 2**64 - 1
+
+    # Set a breakpoint on malloc, located in libc
+    debugger.breakpoint("malloc", callback=bad_malloc, file="libc")
+
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+def test_integer_overflow():
+    number = base64.b64encode(b"123456789012345678901234567890")
+    debugger, pipe, breakpoints = setup_debugger()
+    debugger.cont()
+    pipe.recvline()
+    pipe.sendline(number)
+    debugger.wait()
+    register_coverage(breakpoints)
+    assert pipe.recvline().strip() == b"Invalid input string"
+    debugger.terminate()
+
+if __name__ == "__main__":
+    print("Testing correct input")
+    test_correct_input()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing invalid input: empty string")
+    test_empty_string()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing invalid input: bad base64 length")
+    test_invalid_length_base64()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing invalid input: bad base64 characters")
+    test_invalid_base64_characters()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing all valid base64 characters")
+    test_out_of_range_base64_characters_1()
+    test_out_of_range_base64_characters_2()
+    test_out_of_range_base64_characters_3()
+    test_out_of_range_base64_characters_4()
+    test_out_of_range_base64_characters_5()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing invalid input: null input")
+    test_null_input()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing malloc failure")
+    test_malloc_failure()
+    print(f"Coverage: {calculate_coverage()}")
+    print("Testing integer overflow")
+    test_integer_overflow()
+    print(f"Coverage: {calculate_coverage()}")
diff --git a/examples/codecov/main b/examples/codecov/main
new file mode 100755
index 00000000..df9fad03
Binary files /dev/null and b/examples/codecov/main differ
diff --git a/examples/codecov/main.c b/examples/codecov/main.c
new file mode 100644
index 00000000..f49fbbdb
--- /dev/null
+++ b/examples/codecov/main.c
@@ -0,0 +1,111 @@
+//
+// This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+// Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int long_from_base64_decimal_str(char *str)
+{
+    // Validate that the input string is not NULL
+    if (str == NULL) {
+        return -1;
+    }
+
+    size_t len = strlen(str);
+
+    // Validate that the input string is not empty
+    if (len == 0) {
+        return -1;
+    }
+
+    // Validate that the input string is a multiple of 4
+    if (len % 4 != 0) {
+        return -1;
+    }
+
+    // Validate that the input string is a valid base64 string
+    for (size_t i = 0; i < len; i++) {
+        if (str[i] < 0x20 || str[i] > 0x7E) {
+            return -1;
+        }
+    }
+
+    // Convert the base64 string to its byte values
+    for (size_t i = 0; i < len; i++) {
+        if (str[i] >= 'A' && str[i] <= 'Z') {
+            str[i] = str[i] - 'A';
+        } else if (str[i] >= 'a' && str[i] <= 'z') {
+            str[i] = str[i] - 'a' + 26;
+        } else if (str[i] >= '0' && str[i] <= '9') {
+            str[i] = str[i] - '0' + 52;
+        } else if (str[i] == '+') {
+            str[i] = 62;
+        } else if (str[i] == '/') {
+            str[i] = 63;
+        } else if (str[i] == '=') {
+            str[i] = 0;
+        } else {
+            return -1;
+        }
+    }
+
+    // Allocate memory for the decoded string
+    char *dec_str = (char *)malloc(len);
+
+    // Validate that the memory allocation was successful
+    if (dec_str == NULL) {
+        return -1;
+    }
+
+    // Decode the base64 string
+    size_t j = 0;
+    for (size_t i = 0; i < len; i += 4, j += 3) {
+        dec_str[j] = (str[i] << 2) | (str[i + 1] >> 4);
+        dec_str[j + 1] = (str[i + 1] << 4) | (str[i + 2] >> 2);
+        dec_str[j + 2] = (str[i + 2] << 6) | str[i + 3];
+    }
+
+    long result = 0;
+
+    // Clear errno
+    errno = 0;
+
+    // Convert the decoded string to a long
+    result = strtol(dec_str, NULL, 10);
+
+    // Check for errors during the conversion
+    if (errno != 0) {
+        // Free the memory allocated for the decoded string
+        free(dec_str);
+        return -1;
+    }
+
+    // Free the memory allocated for the decoded string
+    free(dec_str);
+
+    return result;
+}
+
+int main()
+{
+    puts("Please enter a base64 decimal string:");
+
+    char str[256];
+    fgets(str, sizeof(str), stdin);
+
+    // Remove the newline character from the input string
+    str[strcspn(str, "\n")] = '\0';
+
+    long result = long_from_base64_decimal_str(str);
+
+    if (result == -1) {
+        puts("Invalid input string");
+    } else {
+        printf("%ld\n", result);
+    }
+}
\ No newline at end of file
diff --git a/examples/python_bytecode_debugging/libpython3.12.so.1.0 b/examples/python_bytecode_debugging/libpython3.12.so.1.0
new file mode 100755
index 00000000..10d8ef0e
Binary files /dev/null and b/examples/python_bytecode_debugging/libpython3.12.so.1.0 differ
diff --git a/examples/python_bytecode_debugging/output b/examples/python_bytecode_debugging/output
new file mode 100644
index 00000000..8169d111
--- /dev/null
+++ b/examples/python_bytecode_debugging/output
@@ -0,0 +1,21 @@
+Executed opcode: 0x97 - RESUME
+Executed opcode: 0x64 - LOAD_CONST
+Executed opcode: 0x5a - STORE_NAME
+Executed opcode: 0x64 - LOAD_CONST
+Executed opcode: 0x5a - STORE_NAME
+Executed opcode: 0x64 - LOAD_CONST
+Executed opcode: 0x5a - STORE_NAME
+Executed opcode: 0x65 - LOAD_NAME
+Executed opcode: 0x65 - LOAD_NAME
+Executed opcode: 0x7a - BINARY_OP
+Executed opcode: 0x65 - LOAD_NAME
+Executed opcode: 0x7a - BINARY_OP
+Executed opcode: 0x5a - STORE_NAME
+Executed opcode: 0x2 - PUSH_NULL
+Executed opcode: 0x65 - LOAD_NAME
+Executed opcode: 0x65 - LOAD_NAME
+Executed opcode: 0xab - CALL
+Executed opcode: 0x1 - POP_TOP
+Executed opcode: 0x79 - RETURN_CONST
+Executed opcode: 0x3 - INTERPRETER_EXIT
+The result printed by the python script is: -40
diff --git a/examples/python_bytecode_debugging/python3.12 b/examples/python_bytecode_debugging/python3.12
new file mode 100755
index 00000000..e8cf2b6b
Binary files /dev/null and b/examples/python_bytecode_debugging/python3.12 differ
diff --git a/examples/python_bytecode_debugging/python_bytecode_dumper.py b/examples/python_bytecode_debugging/python_bytecode_dumper.py
new file mode 100644
index 00000000..c1eb59d9
--- /dev/null
+++ b/examples/python_bytecode_debugging/python_bytecode_dumper.py
@@ -0,0 +1,146 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from libdebug import debugger, libcontext
+from capstone import Cs, CS_ARCH_X86, CS_MODE_64
+from elftools.elf.elffile import ELFFile
+
+
+##############################################################
+######    Automatically find the offsets of interest    ######
+##############################################################
+
+def find_patterns_in_section(section, md):
+    """Find patterns in the given section. We want to find every DISPATCHER inlined in the libpython shared library."""
+    jmp_rax_offsets = []
+    prev_instructions = []
+
+    for i in md.disasm(section.data(), section['sh_addr']):
+        prev_instructions.append((i.mnemonic, i.op_str))
+        if len(prev_instructions) > 3:
+            prev_instructions.pop(0)
+
+        if len(prev_instructions) == 3:
+            if (prev_instructions[0] == ('movzx', 'eax, r15b') and
+                (prev_instructions[1] == ('mov', 'rax, qword ptr [rdi + rax*8]') 
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rbx + rax*8]')
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rdx + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rcx + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [r8 + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [r9 + rax*8]')
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rsi + rax*8]')
+                )
+                and
+                prev_instructions[2] == ('jmp', 'rax')):
+                jmp_rax_offsets.append(i.address)
+            elif (prev_instructions[0] == ('mov', 'r15, rax') and
+                (prev_instructions[1] == ('mov', 'rax, qword ptr [rdi + rax*8]') 
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rbx + rax*8]')
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rdx + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rcx + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [r8 + rax*8]')
+                or 
+                prev_instructions[1] == ('mov', 'rax, qword ptr [r9 + rax*8]')
+                or
+                prev_instructions[1] == ('mov', 'rax, qword ptr [rsi + rax*8]')
+                )
+                and
+                prev_instructions[2] == ('jmp', 'rax')):
+                jmp_rax_offsets.append(i.address)
+
+    return jmp_rax_offsets
+
+with open('./libpython3.12.so.1.0', 'rb') as f:
+    elf = ELFFile(f)
+    md = Cs(CS_ARCH_X86, CS_MODE_64)
+
+    # Collect all offsets from executable sections
+    all_offsets = []
+    for section in elf.iter_sections():
+        if section['sh_flags'] & 0x4:  # SHF_EXECINSTR
+            offsets = find_patterns_in_section(section, md)
+            all_offsets.extend(offsets)
+
+
+##############################################################
+######  Dump the executed python opcodes with libdebug  ######
+##############################################################
+
+# Create a dictionary with python opcodes as keys and mnemonics as values.
+# The dict is hardcoded to avoid differences in the opcode values between
+# the python versions used to dump the opcodes and the python version of 
+# the python interpreter used to execute the python script under analysis.
+opcode_to_mnemonic = {
+    0x97: "RESUME",
+    0x64: "LOAD_CONST",
+    0x5a: "STORE_NAME",
+    0x65: "LOAD_NAME",
+    0x7a: "BINARY_OP",
+    0x2: "PUSH_NULL",
+    0xab: "CALL",
+    0x1: "POP_TOP",
+    0x79: "RETURN_CONST",
+    0x3: "INTERPRETER_EXIT"
+}
+
+def dumper(t,_):
+    """Callback function to dump the executed python opcode."""
+    print(f"Executed opcode: {t.regs.r15:#x} - {opcode_to_mnemonic.get(t.regs.r15, 'UNKNOWN')}")
+
+d = debugger(["./python3.12", "python_script.py"], env={"LD_LIBRARY_PATH": "."})
+
+# Set the symbol level to 5, this will enable the debugger to resolve symbols using debuinfod files
+libcontext.sym_lvl = 5 
+
+r = d.run()
+
+# This function is executed before each chunk of python bytecode is interpreted
+bp_run_mod = d.breakpoint("run_mod", file = "libpython3", hardware=True)
+
+# Start the execution
+d.cont()
+
+# Wait for the breakpoint to be hit
+d.wait()
+
+while bp_run_mod.hit_on(d):
+        if bp_run_mod.hit_count == 2:
+            # At this point of the execution, the python bytecode releted to the python script
+            # is executed. We can now set breakpoints on the offsets we found in the shared library
+            for addr in all_offsets:
+                d.breakpoint(addr, callback=dumper, file = "libpython3")
+            # Set a breakpoint on the _PyArena_Free function, executed when the python script ends 
+            bp_py_arena_free = d.breakpoint("_PyArena_Free", file = "libpython3")
+            # Set a breakpoint on the binary operation function
+            bp_binary_op = d.breakpoint(0x189f93, file = "libpython3")
+        d.cont()
+        d.wait()
+
+while bp_binary_op.hit_on(d):
+    # Transform the binary operation into a subtraction
+    d.regs.rdx = 0xa # 0xa is the subtraction
+    d.cont()
+    d.wait()
+
+if bp_py_arena_free.hit_on(d):
+    # The python script has ended, we can now disable the breakpoints
+    bp_py_arena_free.disable()
+    for bp in d.breakpoints.values():
+        bp.disable()
+
+print("The result printed by the python script is:", r.recvline().decode())
+
+d.kill()
\ No newline at end of file
diff --git a/examples/python_bytecode_debugging/python_script.py b/examples/python_bytecode_debugging/python_script.py
new file mode 100644
index 00000000..9c7c185b
--- /dev/null
+++ b/examples/python_bytecode_debugging/python_script.py
@@ -0,0 +1,5 @@
+a = 10 
+b = 20
+c = 30
+d = a + b + c
+print(d)
\ No newline at end of file
diff --git a/libdebug/architectures/amd64/amd64_stack_unwinder.py b/libdebug/architectures/amd64/amd64_stack_unwinder.py
index a07e077a..0a82e8b4 100644
--- a/libdebug/architectures/amd64/amd64_stack_unwinder.py
+++ b/libdebug/architectures/amd64/amd64_stack_unwinder.py
@@ -9,10 +9,13 @@
 from typing import TYPE_CHECKING
 
 from libdebug.architectures.stack_unwinding_manager import StackUnwindingManager
+from libdebug.liblog import logging
 
 if TYPE_CHECKING:
     from libdebug.state.thread_context import ThreadContext
 
+
+
 class Amd64StackUnwinder(StackUnwindingManager):
     """Class that provides stack unwinding for the x86_64 architecture."""
 
@@ -48,6 +51,18 @@ def unwind(self: Amd64StackUnwinder, target: ThreadContext) -> list:
             except (OSError, ValueError):
                 break
 
+        # If we are in the prolouge of a function, we need to get the return address from the stack
+        # using a slightly more complex method
+        try:
+            first_return_address = self.get_return_address(target)
+
+            if first_return_address != stack_trace[1]:
+                stack_trace.insert(1, first_return_address)
+        except (OSError, ValueError):
+            logging.WARNING(
+                "Failed to get the return address from the stack. Check stack frame registers (e.g., base pointer). The stack trace may be incomplete.",
+            )
+
         return stack_trace
 
     def get_return_address(self: Amd64StackUnwinder, target: ThreadContext) -> int:
diff --git a/libdebug/cffi/ptrace_cffi_source.c b/libdebug/cffi/ptrace_cffi_source.c
index f843b250..8ee7da4e 100644
--- a/libdebug/cffi/ptrace_cffi_source.c
+++ b/libdebug/cffi/ptrace_cffi_source.c
@@ -554,9 +554,15 @@ void enable_breakpoint(struct global_state *state, uint64_t address)
     while (b != NULL) {
         if (b->addr == address) {
             b->enabled = 1;
+            break;
         }
         b = b->next;
     }
+
+    // Patch the instruction with the breakpoint
+    if (b != NULL) {
+        ptrace(PTRACE_POKEDATA, state->t_HEAD->tid, (void *)address, b->patched_instruction);
+    }
 }
 
 void disable_breakpoint(struct global_state *state, uint64_t address)
@@ -566,9 +572,15 @@ void disable_breakpoint(struct global_state *state, uint64_t address)
     while (b != NULL) {
         if (b->addr == address) {
             b->enabled = 0;
+            break;
         }
         b = b->next;
     }
+
+    // Restore the original instruction
+    if (b != NULL) {
+        ptrace(PTRACE_POKEDATA, state->t_HEAD->tid, (void *)address, b->instruction);
+    }
 }
 
 void free_breakpoints(struct global_state *state)
diff --git a/libdebug/data/memory_view.py b/libdebug/data/memory_view.py
index 64c0c9de..44ef6793 100644
--- a/libdebug/data/memory_view.py
+++ b/libdebug/data/memory_view.py
@@ -151,23 +151,29 @@ def _manage_memory_read_type(self: MemoryView, key: int | slice | str | tuple, f
             the "binary" map file).
         """
         if isinstance(key, int):
-            address = self._internal_debugger.resolve_address(key, file)
-            return self.read(address, 1)
+            address = self._internal_debugger.resolve_address(key, file, skip_absolute_address_validation=True)
+            try:
+                return self.read(address, 1)
+            except OSError as e:
+                raise ValueError("Invalid address.") from e
         elif isinstance(key, slice):
             if isinstance(key.start, str):
                 start = self._internal_debugger.resolve_symbol(key.start, file)
             else:
-                start = self._internal_debugger.resolve_address(key.start, file)
+                start = self._internal_debugger.resolve_address(key.start, file, skip_absolute_address_validation=True)
 
             if isinstance(key.stop, str):
                 stop = self._internal_debugger.resolve_symbol(key.stop, file)
             else:
-                stop = self._internal_debugger.resolve_address(key.stop, file)
+                stop = self._internal_debugger.resolve_address(key.stop, file, skip_absolute_address_validation=True)
 
             if stop < start:
                 raise ValueError("Invalid slice range.")
 
-            return self.read(start, stop - start)
+            try:
+                return self.read(start, stop - start)
+            except OSError as e:
+                raise ValueError("Invalid address.") from e
         elif isinstance(key, str):
             address = self._internal_debugger.resolve_symbol(key, file)
 
@@ -207,11 +213,14 @@ def _manage_memory_read_tuple(self: MemoryView, key: tuple) -> bytes:
         if isinstance(address, str):
             address = self._internal_debugger.resolve_symbol(address, file)
         elif isinstance(address, int):
-            address = self._internal_debugger.resolve_address(address, file)
+            address = self._internal_debugger.resolve_address(address, file, skip_absolute_address_validation=True)
         else:
             raise TypeError("Invalid type for the address. Expected int or string.")
 
-        return self.read(address, size)
+        try:
+            return self.read(address, size)
+        except OSError as e:
+            raise ValueError("Invalid address.") from e
 
     def _manage_memory_write_type(
         self: MemoryView,
@@ -229,19 +238,26 @@ def _manage_memory_write_type(
             the "binary" map file).
         """
         if isinstance(key, int):
-            address = self._internal_debugger.resolve_address(key, file)
-            self.write(address, value)
+            address = self._internal_debugger.resolve_address(key, file, skip_absolute_address_validation=True)
+            try:
+                self.write(address, value)
+            except OSError as e:
+                raise ValueError("Invalid address.") from e
         elif isinstance(key, slice):
             if isinstance(key.start, str):
                 start = self._internal_debugger.resolve_symbol(key.start, file)
             else:
-                start = self._internal_debugger.resolve_address(key.start, file)
+                start = self._internal_debugger.resolve_address(key.start, file, skip_absolute_address_validation=True)
 
             if key.stop is not None:
                 if isinstance(key.stop, str):
                     stop = self._internal_debugger.resolve_symbol(key.stop, file)
                 else:
-                    stop = self._internal_debugger.resolve_address(key.stop, file)
+                    stop = self._internal_debugger.resolve_address(
+                        key.stop,
+                        file,
+                        skip_absolute_address_validation=True,
+                    )
 
                 if stop < start:
                     raise ValueError("Invalid slice range")
@@ -249,7 +265,10 @@ def _manage_memory_write_type(
                 if len(value) != stop - start:
                     liblog.warning(f"Mismatch between slice width and value size, writing {len(value)} bytes.")
 
-            self.write(start, value)
+            try:
+                self.write(start, value)
+            except OSError as e:
+                raise ValueError("Invalid address.") from e
 
         elif isinstance(key, str):
             address = self._internal_debugger.resolve_symbol(key, file)
@@ -292,14 +311,17 @@ def _manage_memory_write_tuple(self: MemoryView, key: tuple, value: bytes) -> No
         if isinstance(address, str):
             address = self._internal_debugger.resolve_symbol(address, file)
         elif isinstance(address, int):
-            address = self._internal_debugger.resolve_address(address, file)
+            address = self._internal_debugger.resolve_address(address, file, skip_absolute_address_validation=True)
         else:
             raise TypeError("Invalid type for the address. Expected int or string.")
 
         if len(value) != size:
             liblog.warning(f"Mismatch between specified size and actual value size, writing {len(value)} bytes.")
 
-        self.write(address, value)
+        try:
+            self.write(address, value)
+        except OSError as e:
+            raise ValueError("Invalid address.") from e
 
     def __delitem__(self: MemoryView, key: int | slice | str | tuple) -> None:
         """MemoryView doesn't support deletion."""
diff --git a/libdebug/debugger/internal_debugger.py b/libdebug/debugger/internal_debugger.py
index 25a7e386..107d1cc9 100644
--- a/libdebug/debugger/internal_debugger.py
+++ b/libdebug/debugger/internal_debugger.py
@@ -207,7 +207,7 @@ def start_processing_thread(self: InternalDebugger) -> None:
         )
         self.__polling_thread.start()
 
-    def _background_invalid_call(self: InternalDebugger) -> None:
+    def _background_invalid_call(self: InternalDebugger, *_: ..., **__: ...) -> None:
         """Raises an error when an invalid call is made in background mode."""
         raise RuntimeError("This method is not available in a callback.")
 
@@ -994,12 +994,18 @@ def get_thread_by_id(self: InternalDebugger, thread_id: int) -> ThreadContext:
 
         return None
 
-    def resolve_address(self: InternalDebugger, address: int, backing_file: str) -> int:
+    def resolve_address(
+        self: InternalDebugger,
+        address: int,
+        backing_file: str,
+        skip_absolute_address_validation: bool = False,
+    ) -> int:
         """Normalizes and validates the specified address.
 
         Args:
             address (int): The address to normalize and validate.
             backing_file (str): The backing file to resolve the address in.
+            skip_absolute_address_validation (bool, optional): Whether to skip bounds checking for absolute addresses. Defaults to False.
 
         Returns:
             int: The normalized and validated address.
@@ -1007,6 +1013,9 @@ def resolve_address(self: InternalDebugger, address: int, backing_file: str) ->
         Raises:
             ValueError: If the substring `backing_file` is present in multiple backing files.
         """
+        if skip_absolute_address_validation and backing_file == "absolute":
+            return address
+
         maps = self.debugging_interface.maps()
 
         if backing_file in ["hybrid", "absolute"]:
@@ -1285,12 +1294,9 @@ def __threaded_migrate_from_gdb(self: InternalDebugger) -> None:
         self.debugging_interface.migrate_from_gdb()
 
     def __threaded_peek_memory(self: InternalDebugger, address: int) -> bytes | BaseException:
-        try:
-            value = self.debugging_interface.peek_memory(address)
-            # TODO: this is only for amd64
-            return value.to_bytes(8, "little")
-        except BaseException as e:
-            return e
+        value = self.debugging_interface.peek_memory(address)
+        # TODO: this is only for amd64
+        return value.to_bytes(8, "little")
 
     def __threaded_poke_memory(self: InternalDebugger, address: int, data: bytes) -> None:
         int_data = int.from_bytes(data, "little")
diff --git a/libdebug/liblog.py b/libdebug/liblog.py
index b118b350..0e377047 100644
--- a/libdebug/liblog.py
+++ b/libdebug/liblog.py
@@ -32,12 +32,16 @@ def __init__(self: LibLog) -> None:
         if self._initialized:
             return
 
+        # Add custom log levels
+        logging.addLevelName(60, "SILENT")
+        logging.SILENT = 60
+
         # General logger
         self.general_logger = self._setup_logger("libdebug", logging.INFO)
 
         # Component-specific loggers
-        self.debugger_logger = self._setup_logger("debugger", logging.INFO)
-        self.pipe_logger = self._setup_logger("pipe", logging.INFO)
+        self.debugger_logger = self._setup_logger("debugger", logging.SILENT)
+        self.pipe_logger = self._setup_logger("pipe", logging.SILENT)
 
         self._initialized = True
 
diff --git a/libdebug/ptrace/ptrace_status_handler.py b/libdebug/ptrace/ptrace_status_handler.py
index dbdc0bf2..2717ac13 100644
--- a/libdebug/ptrace/ptrace_status_handler.py
+++ b/libdebug/ptrace/ptrace_status_handler.py
@@ -77,37 +77,33 @@ def _handle_breakpoints(self: PtraceStatusHandler, thread_id: int) -> bool:
 
         bp: None | Breakpoint
 
-        enabled_breakpoints = {}
-        for bp in self.internal_debugger.breakpoints.values():
-            if bp.enabled and not bp._disabled_for_step:
-                enabled_breakpoints[bp.address] = bp
-
-        bp = None
-
-        if ip in enabled_breakpoints:
+        bp = self.internal_debugger.breakpoints.get(ip)
+        if bp and bp.enabled and not bp._disabled_for_step:
             # Hardware breakpoint hit
             liblog.debugger("Hardware breakpoint hit at 0x%x", ip)
-            bp = self.internal_debugger.breakpoints[ip]
         else:
             # If the trap was caused by a software breakpoint, we need to restore the original instruction
             # and set the instruction pointer to the previous instruction.
             ip -= software_breakpoint_byte_size()
 
-            if ip in enabled_breakpoints:
+            bp = self.internal_debugger.breakpoints.get(ip)
+            if bp and bp.enabled and not bp._disabled_for_step:
                 # Software breakpoint hit
                 liblog.debugger("Software breakpoint hit at 0x%x", ip)
-                bp = self.internal_debugger.breakpoints[ip]
 
                 # Set the instruction pointer to the previous instruction
                 thread.instruction_pointer = ip
 
                 # Link the breakpoint to the thread, so that we can step over it
                 bp._linked_thread_ids.append(thread_id)
+            else:
+                # If the breakpoint has been hit but is not enabled, we need to reset the bp variable
+                bp = None
 
         # Manage watchpoints
-        if bp is None:
+        if not bp:
             bp = self.ptrace_interface.hardware_bp_helpers[thread_id].is_watchpoint_hit()
-            if bp is not None:
+            if bp:
                 liblog.debugger("Watchpoint hit at 0x%x", bp.address)
 
         if bp:
diff --git a/libdebug/state/thread_context.py b/libdebug/state/thread_context.py
index f0b5d193..c65d0e0b 100644
--- a/libdebug/state/thread_context.py
+++ b/libdebug/state/thread_context.py
@@ -13,6 +13,7 @@
 )
 from libdebug.liblog import liblog
 from libdebug.utils.debugging_utils import resolve_address_in_maps
+from libdebug.utils.print_style import PrintStyle
 from libdebug.utils.signal_utils import resolve_signal_name, resolve_signal_number
 
 if TYPE_CHECKING:
@@ -173,20 +174,44 @@ def signal(self: ThreadContext, signal: str | int) -> None:
         self._signal_number = signal
         self._internal_debugger.resume_context.threads_with_signals_to_forward.append(self.thread_id)
 
-    def backtrace(self: ThreadContext) -> list:
-        """Returns the current backtrace of the thread."""
-        internal_debugger = self._internal_debugger
-        internal_debugger._ensure_process_stopped()
+    def backtrace(self: ThreadContext, as_symbols: bool = False) -> list:
+        """Returns the current backtrace of the thread.
+
+        Args:
+            as_symbols (bool, optional): Whether to return the backtrace as symbols
+        """
+        self._internal_debugger._ensure_process_stopped()
+        stack_unwinder = stack_unwinding_provider()
+        backtrace = stack_unwinder.unwind(self)
+        if as_symbols:
+            maps = self._internal_debugger.debugging_interface.maps()
+            backtrace = [resolve_address_in_maps(x, maps) for x in backtrace]
+        return backtrace
+
+    def print_backtrace(self: ThreadContext) -> None:
+        """Prints the current backtrace of the thread."""
+        self._internal_debugger._ensure_process_stopped()
         stack_unwinder = stack_unwinding_provider()
         backtrace = stack_unwinder.unwind(self)
-        maps = internal_debugger.debugging_interface.maps()
-        return [resolve_address_in_maps(x, maps) for x in backtrace]
+        maps = self._internal_debugger.debugging_interface.maps()
+        for return_address in backtrace:
+            return_address_symbol = resolve_address_in_maps(return_address, maps)
+            if return_address_symbol[:2] == "0x":
+                print(f"{PrintStyle.RED}{return_address:#x} {PrintStyle.RESET}")
+            else:
+                print(f"{PrintStyle.RED}{return_address:#x} <{return_address_symbol}> {PrintStyle.RESET}")
 
     def current_return_address(self: ThreadContext) -> int:
         """Returns the return address of the current function."""
         self._internal_debugger._ensure_process_stopped()
         stack_unwinder = stack_unwinding_provider()
-        return stack_unwinder.get_return_address(self)
+        
+        try:
+            return_address = stack_unwinder.get_return_address(self)
+        except (OSError, ValueError) as e:
+            raise ValueError("Failed to get the return address. Check stack frame registers (e.g., base pointer).") from e
+        
+        return return_address
 
     def step(self: ThreadContext) -> None:
         """Executes a single instruction of the process."""
diff --git a/libdebug/utils/elf_utils.py b/libdebug/utils/elf_utils.py
index f441040e..f01e989f 100644
--- a/libdebug/utils/elf_utils.py
+++ b/libdebug/utils/elf_utils.py
@@ -53,6 +53,7 @@ def _debuginfod(buildid: str) -> Path:
     debuginfod_path = Path.home() / ".cache" / "debuginfod_client" / buildid / "debuginfo"
 
     if not debuginfod_path.exists():
+        liblog.info(f"Downloading debuginfo file for buildid {buildid}")
         _download_debuginfod(buildid, debuginfod_path)
 
     return debuginfod_path
diff --git a/libdebug/utils/libcontext.py b/libdebug/utils/libcontext.py
index 22029f33..f502f9cc 100644
--- a/libdebug/utils/libcontext.py
+++ b/libdebug/utils/libcontext.py
@@ -17,6 +17,9 @@ class LibContext:
     """A class that holds the global context of the library."""
 
     _instance = None
+    _pipe_logger_levels: list[str]
+    _debugger_logger_levels: list[str]
+    _general_logger_levels: list[str]
 
     def __new__(cls: type):
         """Create a new instance of the class if it does not exist yet.
@@ -34,10 +37,13 @@ def __init__(self: LibContext) -> None:
         if self._initialized:
             return
 
+        self._pipe_logger_levels = ["DEBUG", "SILENT"]
+        self._debugger_logger_levels = ["DEBUG", "SILENT"]
+        self._general_logger_levels = ["DEBUG", "INFO", "WARNING", "SILENT"]
         self._sym_lvl = 3
 
-        self._debugger_logger = "INFO"
-        self._pipe_logger = "INFO"
+        self._debugger_logger = "SILENT"
+        self._pipe_logger = "SILENT"
         self._general_logger = "INFO"
 
         # Adjust log levels based on command-line arguments
@@ -95,12 +101,14 @@ def debugger_logger(self: LibContext) -> str:
 
     @debugger_logger.setter
     def debugger_logger(self: LibContext, value: str) -> None:
-        """Property setter for debugger_logger, ensuring it's a valid logging level."""
-        if value in ["DEBUG", "INFO"]:
+        """Property setter for debugger_logger, ensuring it's a supported logging level."""
+        if value in self._debugger_logger_levels:
             self._debugger_logger = value
             liblog.debugger_logger.setLevel(value)
         else:
-            raise ValueError("debugger_logger must be a valid logging level")
+            raise ValueError(
+                f"debugger_logger must be a supported logging level. The supported levels are: {self._debugger_logger_levels}",
+            )
 
     @property
     def pipe_logger(self: LibContext) -> str:
@@ -113,12 +121,14 @@ def pipe_logger(self: LibContext) -> str:
 
     @pipe_logger.setter
     def pipe_logger(self: LibContext, value: str) -> None:
-        """Property setter for pipe_logger, ensuring it's a valid logging level."""
-        if value in ["DEBUG", "INFO"]:
+        """Property setter for pipe_logger, ensuring it's a supported logging level."""
+        if value in self._pipe_logger_levels:
             self._pipe_logger = value
             liblog.pipe_logger.setLevel(value)
         else:
-            raise ValueError("pipe_logger must be a valid logging level")
+            raise ValueError(
+                f"pipe_logger must be a supported logging level. The supported levels are: {self._pipe_logger_levels}",
+            )
 
     @property
     def general_logger(self: LibContext) -> str:
@@ -131,12 +141,14 @@ def general_logger(self: LibContext) -> str:
 
     @general_logger.setter
     def general_logger(self: LibContext, value: str) -> None:
-        """Property setter for general_logger, ensuring it's a valid logging level."""
-        if value in ["DEBUG", "INFO"]:
+        """Property setter for general_logger, ensuring it's a supported logging level."""
+        if value in self._general_logger_levels:
             self._general_logger = value
             liblog.general_logger.setLevel(value)
         else:
-            raise ValueError("general_logger must be a valid logging level")
+            raise ValueError(
+                f"general_logger must be a supported logging level. The supported levels are: {self._general_logger_levels}",
+            )
 
     @property
     def arch(self: LibContext) -> str:
diff --git a/setup.py b/setup.py
index 48ae5a7f..2eff8455 100644
--- a/setup.py
+++ b/setup.py
@@ -68,8 +68,8 @@ def get_outputs(self):
 
 setup(
     name="libdebug",
-    version="0.5.3",
-    author="JinBlack",
+    version="0.5.4",
+    author="JinBlack, Io_no, MrIndeciso, Frank01001",
     description="A library to debug binary programs",
     packages=find_packages(include=["libdebug", "libdebug.*"]),
     install_requires=["capstone", "pyelftools", "cffi", "requests", "psutil"],
diff --git a/test/Makefile b/test/Makefile
index 2694586e..1be7d276 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -28,6 +28,8 @@ all:
 	$(CC) $(CFLAGS) $(SRC_DIR)/signals_multithread_det_test.c -o $(BIN_DIR)/signals_multithread_det_test $(LDFLAGS)
 	$(CC) $(CFLAGS) $(SRC_DIR)/segfault_test.c -o $(BIN_DIR)/segfault_test $(LDFLAGS)
 	$(CC) $(CFLAGS) $(SRC_DIR)/executable_section_test.c -o $(BIN_DIR)/executable_section_test $(LDFLAGS)
+	$(CC) $(CFLAGS) $(SRC_DIR)/math_loop_test.c -lm -fno-pie -no-pie -o $(BIN_DIR)/math_loop_test $(LDFLAGS)
+
 	
 
 # Clean rule to remove compiled files
diff --git a/test/benchmarks/benchmarks.md b/test/benchmarks/benchmarks.md
new file mode 100644
index 00000000..9eabd610
--- /dev/null
+++ b/test/benchmarks/benchmarks.md
@@ -0,0 +1,50 @@
+# libdebug VS GDB Benchmarks
+The benchmarks were run on libdebug 0.5.4 and GDB 15.1
+
+## System Information
+```
+$ uname -a
+Linux 6.9.9-arch1-1 #1 SMP PREEMPT_DYNAMIC Fri, 12 Jul 2024 00:06:53 +0000 x86_64 GNU/Linux
+```
+
+<pre>
+                   <span style="color: cyan;">-`</span>                    Neofetch Results
+                  <span style="color: cyan;">.o+`</span>                   ---------------------------
+                 <span style="color: cyan;">`ooo/</span>                   <span style="color: cyan;">OS</span>: Arch Linux x86_64
+                <span style="color: cyan;">`+oooo:</span>                  <span style="color: cyan;">Host</span>: XPS 14 9440
+               <span style="color: cyan;">`+oooooo:</span>                 <span style="color: cyan;">Kernel</span>: 6.9.9-arch1-1
+               <span style="color: cyan;">-+oooooo+:</span>                <span style="color: cyan;">Uptime</span>: 15 mins
+             <span style="color: cyan;">`/:-:++oooo+:</span>               <span style="color: cyan;">Packages</span>: 1038 (pacman), 6 (flatpak)
+            <span style="color: cyan;">`/++++/+++++++:</span>              <span style="color: cyan;">Shell</span>: zsh 5.9
+           <span style="color: cyan;">`/++++++++++++++:</span>             <span style="color: cyan;">Resolution</span>: 1920x1200
+          <span style="color: cyan;">`/+++ooooooooooooo/`</span>           <span style="color: cyan;">DE</span>: GNOME 46.3.1
+         <span style="color: cyan;">./ooosssso++osssssso+`</span>          <span style="color: cyan;">WM</span>: Mutter
+        <span style="color: cyan;">.oossssso-````/ossssss+</span>          <span style="color: cyan;">WM Theme</span>: Adwaita
+       <span style="color: cyan;">-osssssso.      :ssssssso.</span>        <span style="color: cyan;">Theme</span>: Adwaita [GTK2/3]
+      <span style="color: cyan;">:osssssss/        osssso+++.</span>       <span style="color: cyan;">Icons</span>: Adwaita [GTK2/3]
+     <span style="color: cyan;">/ossssssss/        +ssssooo/-</span>       <span style="color: cyan;">Terminal</span>: alacritty
+   <span style="color: cyan;">`/ossssso+/:-        -:/+osssso+-</span>     <span style="color: cyan;">CPU</span>: Intel Ultra 7 155H (22) @ 4.500GHz
+  <span style="color: cyan;">`+sso+:-`                 `.-/+oso:</span>    <span style="color: cyan;">GPU</span>: Intel Arc Graphics
+ <span style="color: cyan;">`++:.                           `-/+/</span>   <span style="color: cyan;">GPU</span>: NVIDIA GeForce RTX 4050 Max-Q / Mobile
+ <span style="color: cyan;">.`                                 `/</span>   <span style="color: cyan;">Memory</span>: 3809MiB / 63749MiB
+</pre>
+
+## Folder structure
+In this folder, you will find all python scripts to run experiments on both libdebug and GDB. The available benchmarks are on breakpoint hits and syscall handling.
+
+The *results* folder contains Python pickles of the lists of time required for each run as well as the extracted boxplots for the distributions.
+
+## Replicating the benchmarks
+
+### GDB Scripts
+GDB is not designed to be scriptable. However, it is possible to implement some custom commands to be run once GDB is loaded. Because of this, the benchmark will include user logs and other overhead. To run a GDB test you need to open GDB with the test script loaded and then run the associated command. E.g.,
+```bash
+gdb -q -x breakpoint_gdb.py
+(gdb) breakpoint_gdb
+```
+
+### libdebug scripts
+Once you have the exact same version of libdebug installed, run the script like any other Python script. E.g.,
+```bash
+python breakpoint_libdebug.py
+```
\ No newline at end of file
diff --git a/test/benchmarks/breakpoint_gdb.py b/test/benchmarks/breakpoint_gdb.py
new file mode 100644
index 00000000..1ae41a6a
--- /dev/null
+++ b/test/benchmarks/breakpoint_gdb.py
@@ -0,0 +1,72 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+import gdb
+from time import perf_counter
+import pickle
+
+class MyBreakpoint(gdb.Breakpoint):
+    """ Class to handle the breakpoint action """
+    def __init__(self, spec):
+        """ Initialize a hardware breakpoint """
+        super(MyBreakpoint, self).__init__(spec, gdb.BP_HARDWARE_BREAKPOINT)
+        self.silent = True
+        
+    def stop(self):
+        """ Callback function to be called at each breakpoint hit """
+        pass
+
+class Debugger(gdb.Command):
+    """ Class to handle the debugging session """
+    def __init__(self):
+        super(Debugger, self).__init__("breakpoint_gdb", gdb.COMMAND_USER)
+        
+    def test(self):
+        """ This test includes the time to:
+        - run the debugged process from the entrypoint,
+        - hit the breakpoint 1000 times,
+        - each time the breakpoint is hit, execute an empty callback,
+        - wait the process to end.
+        """
+        gdb.execute("set pagination off")
+
+        # Start the process (it will stop at the entrypoint)
+        gdb.execute("start")
+        
+        # Set the hardware breakpoint
+        MyBreakpoint("*0x401302")
+        
+        # Start the timer
+        start = perf_counter()
+        
+        # Continue the process from the entrypoint and wait for the process to end
+        gdb.execute("continue")
+        
+        # Stop the timer
+        end = perf_counter()
+
+        # Delete the breakpoints
+        gdb.execute("del breakpoints")
+        
+        self.results.append(end-start)
+
+    def invoke(self, arg, from_tty):
+        # Initialize the results
+        self.results = []
+        
+        # Load the binary
+        binary = "../binaries/math_loop_test"
+        gdb.execute(f"file {binary}")
+        
+        for _ in range(1000):
+            self.test()
+
+        # Save the result in a pickle file
+        with open("breakpoint_gdb.pkl", "wb") as f:
+            pickle.dump(self.results, f)
+        # print("Results:", self.results)
+        
+Debugger()
\ No newline at end of file
diff --git a/test/benchmarks/breakpoint_libdebug.py b/test/benchmarks/breakpoint_libdebug.py
new file mode 100644
index 00000000..790dfd82
--- /dev/null
+++ b/test/benchmarks/breakpoint_libdebug.py
@@ -0,0 +1,62 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from time import perf_counter
+import pickle
+from libdebug import debugger
+
+
+def callback(t,b):
+    """ Callback function to be called at each breakpoint hit """
+    pass
+
+def test():
+    """ This test includes the time to:
+    - run the debugged process from the entrypoint,
+    - hit the breakpoint 1000 times,
+    - each time the breakpoint is hit, execute an empty callback,
+    - wait the process to end.
+    """    
+    # Start the process (it will stop at the entrypoint)
+    d.run()     
+
+    # Set the hardware breakpoint     
+    d.breakpoint(0x401302, callback=callback, hardware=True, file="absolute")
+
+    # Start the timer
+    start = perf_counter()
+    
+    # Continue the process from the entrypoint
+    d.cont()
+
+    # Wait for the process to end
+    d.wait()
+
+    # Stop the timer
+    end = perf_counter()
+    
+    # Kill for a clean exit
+    d.kill()
+
+    results.append(end-start)
+
+# Initialize the results
+results = []
+
+# Initialize the debugger
+d = debugger("../binaries/math_loop_test")
+
+for _ in range(1000):
+    test()
+
+# Terminate the debugger
+d.terminate()
+
+# Save the result in a pickle file
+with open("breakpoint_libdebug.pkl", "wb") as f:
+    pickle.dump(results, f)
+
+# print("Results:", results)  
\ No newline at end of file
diff --git a/test/benchmarks/results/breakpoint_benchmark.svg b/test/benchmarks/results/breakpoint_benchmark.svg
new file mode 100644
index 00000000..8997fcc5
--- /dev/null
+++ b/test/benchmarks/results/breakpoint_benchmark.svg
@@ -0,0 +1,509 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="360pt" height="57.6pt" viewBox="0 0 360 57.6" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2024-07-31T13:33:43.180664</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.7.1, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 57.6 
+L 360 57.6 
+L 360 0 
+L 0 0 
+L 0 57.6 
+z
+" style="fill: none"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 61.36 46.8 
+L 324.18 46.8 
+L 324.18 10.8 
+L 61.36 10.8 
+L 61.36 46.8 
+z
+" style="fill: none"/>
+   </g>
+   <g id="matplotlib.axis_1"/>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="m169217b388" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m169217b388" x="61.36" y="19.8" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- GDB -->
+      <g transform="translate(32.050625 23.599219) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-47" d="M 3809 666 
+L 3809 1919 
+L 2778 1919 
+L 2778 2438 
+L 4434 2438 
+L 4434 434 
+Q 4069 175 3628 42 
+Q 3188 -91 2688 -91 
+Q 1594 -91 976 548 
+Q 359 1188 359 2328 
+Q 359 3472 976 4111 
+Q 1594 4750 2688 4750 
+Q 3144 4750 3555 4637 
+Q 3966 4525 4313 4306 
+L 4313 3634 
+Q 3963 3931 3569 4081 
+Q 3175 4231 2741 4231 
+Q 1884 4231 1454 3753 
+Q 1025 3275 1025 2328 
+Q 1025 1384 1454 906 
+Q 1884 428 2741 428 
+Q 3075 428 3337 486 
+Q 3600 544 3809 666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-42" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-47"/>
+       <use xlink:href="#DejaVuSans-44" x="77.490234"/>
+       <use xlink:href="#DejaVuSans-42" x="154.492188"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_2">
+      <g>
+       <use xlink:href="#m169217b388" x="61.36" y="37.8" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- libdebug -->
+      <g transform="translate(10.919375 41.599219) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-6c" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-69" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-62" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-64" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-65" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-75" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-67" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-6c"/>
+       <use xlink:href="#DejaVuSans-69" x="27.783203"/>
+       <use xlink:href="#DejaVuSans-62" x="55.566406"/>
+       <use xlink:href="#DejaVuSans-64" x="119.042969"/>
+       <use xlink:href="#DejaVuSans-65" x="182.519531"/>
+       <use xlink:href="#DejaVuSans-62" x="244.042969"/>
+       <use xlink:href="#DejaVuSans-75" x="307.519531"/>
+       <use xlink:href="#DejaVuSans-67" x="370.898438"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 131.081253 12.6 
+L 131.081253 27 
+L 143.934293 27 
+L 143.934293 12.6 
+L 131.081253 12.6 
+z
+" clip-path="url(#pc7624c6a5f)" style="fill: #3c6682; stroke: #393939; stroke-linejoin: miter"/>
+   </g>
+   <g id="line2d_3">
+    <path d="M 131.081253 19.8 
+L 122.954944 19.8 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_4">
+    <path d="M 143.934293 19.8 
+L 162.801892 19.8 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_5">
+    <path d="M 122.954944 16.2 
+L 122.954944 23.4 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_6">
+    <path d="M 162.801892 16.2 
+L 162.801892 23.4 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_7">
+    <defs>
+     <path id="m71feee2d49" d="M 0 3 
+C 0.795609 3 1.55874 2.683901 2.12132 2.12132 
+C 2.683901 1.55874 3 0.795609 3 0 
+C 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 
+C 1.55874 -2.683901 0.795609 -3 0 -3 
+C -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 
+C -2.683901 -1.55874 -3 -0.795609 -3 0 
+C -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 
+C -1.55874 2.683901 -0.795609 3 0 3 
+z
+" style="stroke: #393939"/>
+    </defs>
+    <g clip-path="url(#pc7624c6a5f)">
+     <use xlink:href="#m71feee2d49" x="193.535145" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="170.061732" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="207.395575" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="209.390142" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="194.590774" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="179.889829" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="165.580515" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="167.501846" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m71feee2d49" x="184.36792" y="19.8" style="fill-opacity: 0; stroke: #393939"/>
+    </g>
+   </g>
+   <g id="patch_4">
+    <path d="M 81.341118 30.6 
+L 81.341118 45 
+L 88.480193 45 
+L 88.480193 30.6 
+L 81.341118 30.6 
+z
+" clip-path="url(#pc7624c6a5f)" style="fill: #45a778; stroke: #393939; stroke-linejoin: miter"/>
+   </g>
+   <g id="line2d_8">
+    <path d="M 81.341118 37.8 
+L 74.413631 37.8 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_9">
+    <path d="M 88.480193 37.8 
+L 96.708553 37.8 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_10">
+    <path d="M 74.413631 34.2 
+L 74.413631 41.4 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_11">
+    <path d="M 96.708553 34.2 
+L 96.708553 41.4 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_12"/>
+   <g id="line2d_13">
+    <path d="M 138.814806 12.6 
+L 138.814806 27 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_14">
+    <path d="M 84.605722 30.6 
+L 84.605722 45 
+" clip-path="url(#pc7624c6a5f)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 61.36 46.8 
+L 61.36 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 324.18 46.8 
+L 324.18 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 61.36 46.8 
+L 324.18 46.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 61.36 10.8 
+L 324.18 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_3">
+    <!-- (a) -->
+    <g transform="translate(329.4364 32.663125) scale(0.14 -0.14)">
+     <defs>
+      <path id="DejaVuSans-28" d="M 1984 4856 
+Q 1566 4138 1362 3434 
+Q 1159 2731 1159 2009 
+Q 1159 1288 1364 580 
+Q 1569 -128 1984 -844 
+L 1484 -844 
+Q 1016 -109 783 600 
+Q 550 1309 550 2009 
+Q 550 2706 781 3412 
+Q 1013 4119 1484 4856 
+L 1984 4856 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-61" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-29" d="M 513 4856 
+L 1013 4856 
+Q 1481 4119 1714 3412 
+Q 1947 2706 1947 2009 
+Q 1947 1309 1714 600 
+Q 1481 -109 1013 -844 
+L 513 -844 
+Q 928 -128 1133 580 
+Q 1338 1288 1338 2009 
+Q 1338 2731 1133 3434 
+Q 928 4138 513 4856 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-28"/>
+     <use xlink:href="#DejaVuSans-61" x="39.013672"/>
+     <use xlink:href="#DejaVuSans-29" x="100.292969"/>
+    </g>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="pc7624c6a5f">
+   <rect x="61.36" y="10.8" width="262.82" height="36"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/test/benchmarks/results/breakpoint_gdb.pkl b/test/benchmarks/results/breakpoint_gdb.pkl
new file mode 100644
index 00000000..aeca4d03
Binary files /dev/null and b/test/benchmarks/results/breakpoint_gdb.pkl differ
diff --git a/test/benchmarks/results/breakpoint_libdebug.pkl b/test/benchmarks/results/breakpoint_libdebug.pkl
new file mode 100644
index 00000000..4b0e66fb
Binary files /dev/null and b/test/benchmarks/results/breakpoint_libdebug.pkl differ
diff --git a/test/benchmarks/results/syscall_benchmark.svg b/test/benchmarks/results/syscall_benchmark.svg
new file mode 100644
index 00000000..38916074
--- /dev/null
+++ b/test/benchmarks/results/syscall_benchmark.svg
@@ -0,0 +1,945 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="360pt" height="88.2pt" viewBox="0 0 360 88.2" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2024-07-31T13:33:43.413632</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.7.1, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 88.2 
+L 360 88.2 
+L 360 0 
+L 0 0 
+L 0 88.2 
+z
+" style="fill: none"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 61.36 46.24 
+L 323.82 46.24 
+L 323.82 10.8 
+L 61.36 10.8 
+L 61.36 46.24 
+z
+" style="fill: none"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="m798121d99e" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m798121d99e" x="61.36" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- 0.000 -->
+      <g transform="translate(47.045938 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-30" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-30" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_2">
+      <g>
+       <use xlink:href="#m798121d99e" x="105.103333" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- 0.035 -->
+      <g transform="translate(90.789271 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-33" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-35" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-33" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-35" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#m798121d99e" x="148.846667" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <!-- 0.070 -->
+      <g transform="translate(134.532604 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-37" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-37" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-30" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#m798121d99e" x="192.59" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <!-- 0.105 -->
+      <g transform="translate(178.275937 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-31" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-30" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-35" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#m798121d99e" x="236.333333" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <!-- 0.140 -->
+      <g transform="translate(222.019271 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-34" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-31" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-34" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-30" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_6">
+      <g>
+       <use xlink:href="#m798121d99e" x="280.076667" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <!-- 0.175 -->
+      <g transform="translate(265.762604 60.838438) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-31" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-37" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-35" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_7">
+      <g>
+       <use xlink:href="#m798121d99e" x="323.82" y="46.24" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <!-- 0.210 -->
+      <g transform="translate(309.505937 60.838438) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
+       <use xlink:href="#DejaVuSans-32" x="95.410156"/>
+       <use xlink:href="#DejaVuSans-31" x="159.033203"/>
+       <use xlink:href="#DejaVuSans-30" x="222.65625"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_8">
+     <!-- Run time (s) -->
+     <g transform="translate(162.022812 74.516563) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-52" d="M 2841 2188 
+Q 3044 2119 3236 1894 
+Q 3428 1669 3622 1275 
+L 4263 0 
+L 3584 0 
+L 2988 1197 
+Q 2756 1666 2539 1819 
+Q 2322 1972 1947 1972 
+L 1259 1972 
+L 1259 0 
+L 628 0 
+L 628 4666 
+L 2053 4666 
+Q 2853 4666 3247 4331 
+Q 3641 3997 3641 3322 
+Q 3641 2881 3436 2590 
+Q 3231 2300 2841 2188 
+z
+M 1259 4147 
+L 1259 2491 
+L 2053 2491 
+Q 2509 2491 2742 2702 
+Q 2975 2913 2975 3322 
+Q 2975 3731 2742 3939 
+Q 2509 4147 2053 4147 
+L 1259 4147 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-75" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-6e" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-20" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-74" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-69" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-6d" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-65" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-28" d="M 1984 4856 
+Q 1566 4138 1362 3434 
+Q 1159 2731 1159 2009 
+Q 1159 1288 1364 580 
+Q 1569 -128 1984 -844 
+L 1484 -844 
+Q 1016 -109 783 600 
+Q 550 1309 550 2009 
+Q 550 2706 781 3412 
+Q 1013 4119 1484 4856 
+L 1984 4856 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-73" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-29" d="M 513 4856 
+L 1013 4856 
+Q 1481 4119 1714 3412 
+Q 1947 2706 1947 2009 
+Q 1947 1309 1714 600 
+Q 1481 -109 1013 -844 
+L 513 -844 
+Q 928 -128 1133 580 
+Q 1338 1288 1338 2009 
+Q 1338 2731 1133 3434 
+Q 928 4138 513 4856 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-52"/>
+      <use xlink:href="#DejaVuSans-75" x="64.982422"/>
+      <use xlink:href="#DejaVuSans-6e" x="128.361328"/>
+      <use xlink:href="#DejaVuSans-20" x="191.740234"/>
+      <use xlink:href="#DejaVuSans-74" x="223.527344"/>
+      <use xlink:href="#DejaVuSans-69" x="262.736328"/>
+      <use xlink:href="#DejaVuSans-6d" x="290.519531"/>
+      <use xlink:href="#DejaVuSans-65" x="387.931641"/>
+      <use xlink:href="#DejaVuSans-20" x="449.455078"/>
+      <use xlink:href="#DejaVuSans-28" x="481.242188"/>
+      <use xlink:href="#DejaVuSans-73" x="520.255859"/>
+      <use xlink:href="#DejaVuSans-29" x="572.355469"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_8">
+      <defs>
+       <path id="m31660f121a" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m31660f121a" x="61.36" y="19.66" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <!-- GDB -->
+      <g transform="translate(32.050625 23.459219) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-47" d="M 3809 666 
+L 3809 1919 
+L 2778 1919 
+L 2778 2438 
+L 4434 2438 
+L 4434 434 
+Q 4069 175 3628 42 
+Q 3188 -91 2688 -91 
+Q 1594 -91 976 548 
+Q 359 1188 359 2328 
+Q 359 3472 976 4111 
+Q 1594 4750 2688 4750 
+Q 3144 4750 3555 4637 
+Q 3966 4525 4313 4306 
+L 4313 3634 
+Q 3963 3931 3569 4081 
+Q 3175 4231 2741 4231 
+Q 1884 4231 1454 3753 
+Q 1025 3275 1025 2328 
+Q 1025 1384 1454 906 
+Q 1884 428 2741 428 
+Q 3075 428 3337 486 
+Q 3600 544 3809 666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-42" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-47"/>
+       <use xlink:href="#DejaVuSans-44" x="77.490234"/>
+       <use xlink:href="#DejaVuSans-42" x="154.492188"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#m31660f121a" x="61.36" y="37.38" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <!-- libdebug -->
+      <g transform="translate(10.919375 41.179219) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-6c" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-62" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-64" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-67" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-6c"/>
+       <use xlink:href="#DejaVuSans-69" x="27.783203"/>
+       <use xlink:href="#DejaVuSans-62" x="55.566406"/>
+       <use xlink:href="#DejaVuSans-64" x="119.042969"/>
+       <use xlink:href="#DejaVuSans-65" x="182.519531"/>
+       <use xlink:href="#DejaVuSans-62" x="244.042969"/>
+       <use xlink:href="#DejaVuSans-75" x="307.519531"/>
+       <use xlink:href="#DejaVuSans-67" x="370.898438"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 245.439618 12.572 
+L 245.439618 26.748 
+L 258.788243 26.748 
+L 258.788243 12.572 
+L 245.439618 12.572 
+z
+" clip-path="url(#pbba15bb37a)" style="fill: #3c6682; stroke: #393939; stroke-linejoin: miter"/>
+   </g>
+   <g id="line2d_10">
+    <path d="M 245.439618 19.66 
+L 232.103166 19.66 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_11">
+    <path d="M 258.788243 19.66 
+L 277.492942 19.66 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_12">
+    <path d="M 232.103166 16.116 
+L 232.103166 23.204 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_13">
+    <path d="M 277.492942 16.116 
+L 277.492942 23.204 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_14">
+    <defs>
+     <path id="m625fd7f7f3" d="M 0 3 
+C 0.795609 3 1.55874 2.683901 2.12132 2.12132 
+C 2.683901 1.55874 3 0.795609 3 0 
+C 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 
+C 1.55874 -2.683901 0.795609 -3 0 -3 
+C -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 
+C -2.683901 -1.55874 -3 -0.795609 -3 0 
+C -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 
+C -1.55874 2.683901 -0.795609 3 0 3 
+z
+" style="stroke: #393939"/>
+    </defs>
+    <g clip-path="url(#pbba15bb37a)">
+     <use xlink:href="#m625fd7f7f3" x="285.44979" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="284.843891" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="316.358293" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="305.541003" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="314.86986" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="299.130484" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="313.949893" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="284.788506" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="295.576163" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="295.492491" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="285.480651" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="302.151972" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="282.308794" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="282.110318" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="286.668968" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="283.797738" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="315.167557" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="288.250995" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="283.120332" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="280.825383" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="297.50785" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="278.908466" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="298.880167" y="19.66" style="fill-opacity: 0; stroke: #393939"/>
+    </g>
+   </g>
+   <g id="patch_4">
+    <path d="M 104.508299 30.292 
+L 104.508299 44.468 
+L 111.827718 44.468 
+L 111.827718 30.292 
+L 104.508299 30.292 
+z
+" clip-path="url(#pbba15bb37a)" style="fill: #45a778; stroke: #393939; stroke-linejoin: miter"/>
+   </g>
+   <g id="line2d_15">
+    <path d="M 104.508299 37.38 
+L 94.054396 37.38 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_16">
+    <path d="M 111.827718 37.38 
+L 122.674912 37.38 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_17">
+    <path d="M 94.054396 33.836 
+L 94.054396 40.924 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_18">
+    <path d="M 122.674912 33.836 
+L 122.674912 40.924 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939; stroke-linecap: square"/>
+   </g>
+   <g id="line2d_19">
+    <g clip-path="url(#pbba15bb37a)">
+     <use xlink:href="#m625fd7f7f3" x="92.997038" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="93.065895" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="91.84009" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="131.225176" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="129.332944" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="126.793406" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="123.216282" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="124.467683" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="124.436324" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="127.532026" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="123.378578" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="127.42541" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="127.102909" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="130.239627" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="137.483363" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+     <use xlink:href="#m625fd7f7f3" x="125.196496" y="37.38" style="fill-opacity: 0; stroke: #393939"/>
+    </g>
+   </g>
+   <g id="line2d_20">
+    <path d="M 251.102612 12.572 
+L 251.102612 26.748 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="line2d_21">
+    <path d="M 108.88772 30.292 
+L 108.88772 44.468 
+" clip-path="url(#pbba15bb37a)" style="fill: none; stroke: #393939"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 61.36 46.24 
+L 61.36 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 323.82 46.24 
+L 323.82 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 61.36 46.24 
+L 323.82 46.24 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 61.36 10.8 
+L 323.82 10.8 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_11">
+    <!-- (b) -->
+    <g transform="translate(329.0692 32.383125) scale(0.14 -0.14)">
+     <use xlink:href="#DejaVuSans-28"/>
+     <use xlink:href="#DejaVuSans-62" x="39.013672"/>
+     <use xlink:href="#DejaVuSans-29" x="102.490234"/>
+    </g>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="pbba15bb37a">
+   <rect x="61.36" y="10.8" width="262.46" height="35.44"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/test/benchmarks/results/syscall_gdb.pkl b/test/benchmarks/results/syscall_gdb.pkl
new file mode 100644
index 00000000..14302b5e
Binary files /dev/null and b/test/benchmarks/results/syscall_gdb.pkl differ
diff --git a/test/benchmarks/results/syscall_libdebug.pkl b/test/benchmarks/results/syscall_libdebug.pkl
new file mode 100644
index 00000000..e91884e9
Binary files /dev/null and b/test/benchmarks/results/syscall_libdebug.pkl differ
diff --git a/test/benchmarks/syscall_gdb.py b/test/benchmarks/syscall_gdb.py
new file mode 100644
index 00000000..1dddc870
--- /dev/null
+++ b/test/benchmarks/syscall_gdb.py
@@ -0,0 +1,104 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+########################################################################################
+#  This script requires GDB 15.1 or later to run due to the use of the new Python API  #
+########################################################################################
+
+import gdb
+from time import perf_counter
+import pickle
+
+
+# Initialize the global variables
+results = []
+
+def stop_handler(event):
+    """ Callback function to be called at each stop event """
+    if isinstance(event, gdb.StopEvent):
+        # Check if the stop is due the desired syscall
+        if event.details["reason"] == "syscall-entry" and event.details["syscall-number"] == 39:
+            gdb.post_event(lambda: gdb.execute("continue"))
+        elif event.details["reason"] == "syscall-return" and event.details["syscall-number"] == 39:
+            gdb.post_event(lambda: gdb.execute("continue"))
+
+class StartBreakpoint(gdb.Breakpoint):
+    """ Class to handle the breakpoint set just before the main loop """
+    def __init__(self, spec):
+        """ Initialize a hardware breakpoint """
+        super(StartBreakpoint, self).__init__(spec, gdb.BP_HARDWARE_BREAKPOINT)
+        self.silent = True
+        
+    def stop(self):
+        """ Callback function to be called at each breakpoint hit """
+        global start
+        # Start the timer
+        start = perf_counter()
+
+class EndBreakpoint(gdb.Breakpoint):
+    """ Class to handle the breakpoint set right after the main loop """
+    def __init__(self, spec):
+        """ Initialize a hardware breakpoint """
+        super(EndBreakpoint, self).__init__(spec, gdb.BP_HARDWARE_BREAKPOINT)
+        self.silent = True
+        
+    def stop(self):
+        """ Callback function to be called at each breakpoint hit """
+        # Stop the timer
+        end = perf_counter()
+
+        # Kill the process
+        gdb.execute("kill")
+
+        if len(results) < 1000:
+            results.append(end-start)
+            # Restart the process
+            gdb.execute("run")
+        else:
+            # Save the results and quit
+            with open("syscall_gdb.pkl", "wb") as f:
+                pickle.dump(results, f)
+            # print("Results:", results)
+            gdb.execute("quit")
+
+class Debugger(gdb.Command):
+    """ Class to handle the debugging session """
+    def __init__(self):
+        super(Debugger, self).__init__("syscall_gdb", gdb.COMMAND_USER)
+
+    def invoke(self, arg, from_tty):
+        """ This test includes the time to:
+        - run the debugged process from the breakpoint just before the main loop,
+        - manage 1000 calls to the syscall getpid (handled by the stop_handler),
+        - reach the breakpoint right after the main loop,
+        """
+
+        # Load the binary
+        binary = "../binaries/math_loop_test"
+        gdb.execute(f"file {binary}")
+
+        gdb.execute("set confirm off")
+        gdb.execute("set pagination off")
+
+        # Catch the syscall getpid
+        gdb.execute("catch syscall getpid")
+
+        # Connect the stop_handler to the stop event
+        # It will be called at each stop event and will check 
+        # if the syscall getpid is called
+        gdb.events.stop.connect(stop_handler)
+
+        # Start the process (it will stop at the entrypoint)
+        gdb.execute("start")
+
+        # Set the breakpoints before and after the main loop
+        StartBreakpoint("*0x401243")
+        EndBreakpoint("*0x401332")
+
+        # Continue the process from the entrypoint
+        gdb.execute("continue")
+
+Debugger()
\ No newline at end of file
diff --git a/test/benchmarks/syscall_libdebug.py b/test/benchmarks/syscall_libdebug.py
new file mode 100644
index 00000000..6dd4e794
--- /dev/null
+++ b/test/benchmarks/syscall_libdebug.py
@@ -0,0 +1,78 @@
+#
+# This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+# Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from time import perf_counter
+import pickle
+from libdebug import debugger
+
+
+def callback_on_enter(t,b):
+    """ Callback function to be called on syscall entry """
+    pass
+
+def callback_on_exit(t,b):
+    """ Callback function to be called on syscall exit """
+    pass
+
+def start_breakpoint(t,b):
+    """ Callback function to be called each time the breakpoint set just before 
+    the main loop is hit 
+    """
+    global start
+    # Start the timer
+    start = perf_counter()
+
+def end_breakpoint(t,b):
+    """ Callback function to be called each time the breakpoint set right after 
+    the main loop is hit 
+    """
+    # Stop the timer
+    end = perf_counter()
+    # Update the results
+    results.append(end-start)
+
+def test():
+    """ This test includes the time to:
+        - run the debugged process from the breakpoint just before the main loop,
+        - manage 1000 calls to the syscall getpid (each call is handled by the callback functions),
+        - reach the breakpoint right after the main loop,
+    """    
+    # Start the process (it will stop at the entrypoint)
+    d.run()     
+
+    # Set the breakpoints before and after the main loop
+    d.breakpoint(0x401243, hardware=True, callback=start_breakpoint, file="absolute")
+    d.breakpoint(0x401332, hardware=True, callback=end_breakpoint, file="absolute")
+
+    # Handle the syscall getpid, install the callbacks
+    d.handle_syscall("getpid", on_enter=callback_on_enter, on_exit=callback_on_exit)
+
+    # Continue the process from the entrypoint
+    d.cont()
+
+    # Wait for the process to end
+    d.wait()
+
+    # Kill the process
+    d.kill()
+
+# Initialize the results
+results = []
+
+# Initialize the debugger
+d = debugger("../binaries/math_loop_test")
+
+for _ in range(1000):
+    test()
+
+# Terminate the debugger
+d.terminate()
+
+# Save the result in a pickle file
+with open("syscall_libdebug.pkl", "wb") as f:
+    pickle.dump(results, f)
+
+# print("Results:", results)
diff --git a/test/binaries/math_loop_test b/test/binaries/math_loop_test
new file mode 100755
index 00000000..eb209937
Binary files /dev/null and b/test/binaries/math_loop_test differ
diff --git a/test/run_suite.py b/test/run_suite.py
index 8f48b72a..27486054 100644
--- a/test/run_suite.py
+++ b/test/run_suite.py
@@ -52,6 +52,10 @@ def fast_suite():
     suite.addTest(BreakpointTest("test_bp_disable_reenable_hw"))
     suite.addTest(BreakpointTest("test_bps_running"))
     suite.addTest(BreakpointTest("test_bp_backing_file"))
+    suite.addTest(BreakpointTest("test_bp_disable_on_creation"))
+    suite.addTest(BreakpointTest("test_bp_disable_on_creation_2"))
+    suite.addTest(BreakpointTest("test_bp_disable_on_creation_hardware"))
+    suite.addTest(BreakpointTest("test_bp_disable_on_creation_2_hardware"))
     suite.addTest(MemoryTest("test_memory"))
     suite.addTest(MemoryTest("test_mem_access_libs"))
     suite.addTest(MemoryTest("test_memory_access_methods_backing_file"))
@@ -61,6 +65,7 @@ def fast_suite():
     suite.addTest(MemoryTest("test_memory_access_methods"))
     suite.addTest(HwBasicTest("test_basic"))
     suite.addTest(HwBasicTest("test_registers"))
+    suite.addTest(BacktraceTest("test_backtrace_as_symbols"))
     suite.addTest(BacktraceTest("test_backtrace"))
     suite.addTest(AttachDetachTest("test_attach"))
     suite.addTest(AttachDetachTest("test_attach_and_detach_1"))
@@ -111,6 +116,8 @@ def fast_suite():
     suite.addTest(AutoWaitingNlinks("test_nlinks"))
     suite.addTest(WatchpointTest("test_watchpoint"))
     suite.addTest(WatchpointTest("test_watchpoint_callback"))
+    suite.addTest(WatchpointTest("test_watchpoint_disable"))
+    suite.addTest(WatchpointTest("test_watchpoint_disable_reenable"))
     suite.addTest(WatchpointAliasTest("test_watchpoint_alias"))
     suite.addTest(WatchpointAliasTest("test_watchpoint_callback"))
     suite.addTest(HandleSyscallTest("test_handles"))
diff --git a/test/scripts/backtrace_test.py b/test/scripts/backtrace_test.py
index 29cf9237..b2acdae7 100644
--- a/test/scripts/backtrace_test.py
+++ b/test/scripts/backtrace_test.py
@@ -13,7 +13,7 @@ class BacktraceTest(unittest.TestCase):
     def setUp(self):
         self.d = debugger("binaries/backtrace_test")
 
-    def test_backtrace(self):
+    def test_backtrace_as_symbols(self):
         d = self.d
 
         d.run()
@@ -29,28 +29,28 @@ def test_backtrace(self):
         d.cont()
 
         self.assertTrue(d.regs.rip == bp0.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(backtrace[:1], ["main+8"])
 
         d.cont()
 
         self.assertTrue(d.regs.rip == bp1.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(backtrace[:2], ["function1+8", "main+16"])
 
         d.cont()
 
         self.assertTrue(d.regs.rip == bp2.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(backtrace[:3], ["function2+8", "function1+12", "main+16"])
 
         d.cont()
 
         self.assertTrue(d.regs.rip == bp3.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(
             backtrace[:4], ["function3+8", "function2+1c", "function1+12", "main+16"]
@@ -59,7 +59,7 @@ def test_backtrace(self):
         d.cont()
 
         self.assertTrue(d.regs.rip == bp4.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(
             backtrace[:5],
@@ -69,7 +69,7 @@ def test_backtrace(self):
         d.cont()
 
         self.assertTrue(d.regs.rip == bp5.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(
             backtrace[:6],
@@ -86,7 +86,7 @@ def test_backtrace(self):
         d.cont()
 
         self.assertTrue(d.regs.rip == bp6.address)
-        backtrace = d.backtrace()
+        backtrace = d.backtrace(as_symbols=True)
         self.assertIn("_start", backtrace.pop())
         self.assertEqual(
             backtrace[:7],
@@ -103,6 +103,96 @@ def test_backtrace(self):
 
         d.kill()
 
+    def test_backtrace(self):
+        d = self.d
+
+        d.run()
+
+        bp0 = d.breakpoint("main+8")
+        bp1 = d.breakpoint("function1+8")
+        bp2 = d.breakpoint("function2+8")
+        bp3 = d.breakpoint("function3+8")
+        bp4 = d.breakpoint("function4+8")
+        bp5 = d.breakpoint("function5+8")
+        bp6 = d.breakpoint("function6+8")
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp0.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(backtrace[:1], [0x555555555151])
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp1.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(backtrace[:2], [0x55555555518a, 0x55555555515f])
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp2.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(backtrace[:3], [0x55555555519e, 0x555555555194, 0x55555555515f])
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp3.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(
+            backtrace[:4], [0x5555555551bc, 0x5555555551b2, 0x555555555194, 0x55555555515f]
+        )
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp4.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(
+            backtrace[:5],
+            [0x5555555551da, 0x5555555551d0, 0x5555555551b2, 0x555555555194, 0x55555555515f],
+        )
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp5.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(
+            backtrace[:6],
+            [
+                0x5555555551f8,
+                0x5555555551ee,
+                0x5555555551d0,
+                0x5555555551b2,
+                0x555555555194,
+                0x55555555515f,
+            ],
+        )
+
+        d.cont()
+
+        self.assertTrue(d.regs.rip == bp6.address)
+        backtrace = d.backtrace()
+        backtrace.pop()
+        self.assertEqual(
+            backtrace[:7],
+            [
+                0x555555555216,
+                0x55555555520c,
+                0x5555555551ee,
+                0x5555555551d0,
+                0x5555555551b2,
+                0x555555555194,
+                0x55555555515f,
+            ],
+        )
+
+        d.kill()
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/scripts/breakpoint_test.py b/test/scripts/breakpoint_test.py
index 9d77c66b..ea36547b 100644
--- a/test/scripts/breakpoint_test.py
+++ b/test/scripts/breakpoint_test.py
@@ -378,6 +378,75 @@ def test_bp_backing_file(self):
 
         d.kill()
 
+    def test_bp_disable_on_creation(self):
+        d = debugger("binaries/breakpoint_test")
+
+        d.run()
+
+        bp1 = d.bp("random_function")
+        bp2 = d.bp(0x40119c)
+        bp1.disable()
+
+        d.cont()
+
+        assert not bp1.hit_on(d)
+        assert bp2.hit_on(d)
+
+        d.kill()
+        d.terminate()
+
+    def test_bp_disable_on_creation_2(self):
+        d = debugger("binaries/breakpoint_test")
+
+        d.run()
+
+        bp = d.bp("random_function")
+
+        bp.disable()
+
+        d.cont()
+        d.wait()
+
+        # Validate we didn't segfault
+        assert d.dead and d.exit_signal is None
+
+        d.kill()
+        d.terminate()
+
+    def test_bp_disable_on_creation_hardware(self):
+        d = debugger("binaries/breakpoint_test")
+
+        d.run()
+
+        bp1 = d.bp("random_function", hardware=True)
+        bp2 = d.bp(0x40119c)
+        bp1.disable()
+
+        d.cont()
+
+        assert not bp1.hit_on(d)
+        assert bp2.hit_on(d)
+
+        d.kill()
+        d.terminate()
+
+    def test_bp_disable_on_creation_2_hardware(self):
+        d = debugger("binaries/breakpoint_test")
+
+        d.run()
+
+        bp = d.bp("random_function", hardware=True)
+
+        bp.disable()
+
+        d.cont()
+        d.wait()
+
+        # Validate we didn't segfault
+        assert d.dead and d.exit_signal is None
+
+        d.kill()
+        d.terminate()
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/scripts/watchpoint_test.py b/test/scripts/watchpoint_test.py
index ceece1bf..a29b5ae4 100644
--- a/test/scripts/watchpoint_test.py
+++ b/test/scripts/watchpoint_test.py
@@ -15,31 +15,46 @@ def test_watchpoint(self):
 
         d.run()
 
-        d.breakpoint("global_char", hardware=True, condition="rw", length=1)
-        d.breakpoint("global_int", hardware=True, condition="w", length=4)
-        d.breakpoint("global_long", hardware=True, condition="rw", length=8)
+        wp_char = d.breakpoint("global_char", hardware=True, condition="rw", length=1)
+        wp_int = d.breakpoint("global_int", hardware=True, condition="w", length=4)
+        wp_long = d.breakpoint("global_long", hardware=True, condition="rw", length=8)
 
         d.cont()
 
         self.assertEqual(d.regs.rip, 0x401111)  # mov byte ptr [global_char], 0x1
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 0)
+        self.assertEqual(wp_long.hit_count, 0)
 
         d.cont()
 
         self.assertEqual(d.regs.rip, 0x401124)  # mov dword ptr [global_int], 0x4050607
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 0)
 
         d.cont()
 
         self.assertEqual(
             d.regs.rip, 0x401135
         )  # mov qword ptr [global_long], 0x8090a0b0c0d0e0f
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 1)
 
         d.cont()
 
         self.assertEqual(d.regs.rip, 0x401155)  # movzx eax, byte ptr [global_char]
+        self.assertEqual(wp_char.hit_count, 2)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 1)
 
         d.cont()
 
         self.assertEqual(d.regs.rip, 0x401173)  # mov rax, qword ptr [global_long]
+        self.assertEqual(wp_char.hit_count, 2)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 2)
 
         d.cont()
 
@@ -120,3 +135,97 @@ def watchpoint_global_long(t, b):
 
         # There is one extra hit performed by the exit routine of libc
         self.assertEqual(wp3.hit_count, 3)
+
+    def test_watchpoint_disable(self):
+        d = debugger("binaries/watchpoint_test", auto_interrupt_on_command=False)
+
+        d.run()
+
+        wp_char = d.breakpoint("global_char", hardware=True, condition="rw", length=1)
+        wp_int = d.breakpoint("global_int", hardware=True, condition="w", length=4)
+        wp_long = d.breakpoint("global_long", hardware=True, condition="rw", length=8)
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401111)  # mov byte ptr [global_char], 0x1
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 0)
+        self.assertEqual(wp_long.hit_count, 0)
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401124)  # mov dword ptr [global_int], 0x4050607
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 0)
+
+        d.cont()
+
+        self.assertEqual(
+            d.regs.rip, 0x401135
+        )  # mov qword ptr [global_long], 0x8090a0b0c0d0e0f
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 1)
+
+        # disable watchpoint
+        wp_char.disable()
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401173)  # mov rax, qword ptr [global_long]
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 2)
+
+        d.cont()
+
+        d.kill()
+
+    def test_watchpoint_disable_reenable(self):
+        d = debugger("binaries/watchpoint_test", auto_interrupt_on_command=False)
+
+        d.run()
+
+        wp_char = d.breakpoint("global_char", hardware=True, condition="rw", length=1)
+        wp_int = d.breakpoint("global_int", hardware=True, condition="w", length=4)
+        wp_long = d.breakpoint("global_long", hardware=True, condition="rw", length=8)
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401111)  # mov byte ptr [global_char], 0x1
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 0)
+        self.assertEqual(wp_long.hit_count, 0)
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401124)  # mov dword ptr [global_int], 0x4050607
+        self.assertEqual(wp_char.hit_count, 1)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 0)
+
+        # disable watchpoint
+        wp_long.disable()
+
+        d.cont()
+
+
+        self.assertEqual(d.regs.rip, 0x401155)  # movzx eax, byte ptr [global_char]
+        self.assertEqual(wp_char.hit_count, 2)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 0)
+
+        # re-enable watchpoint
+        wp_long.enable()
+
+        d.cont()
+
+        self.assertEqual(d.regs.rip, 0x401173)  # mov rax, qword ptr [global_long]
+        self.assertEqual(wp_char.hit_count, 2)
+        self.assertEqual(wp_int.hit_count, 1)
+        self.assertEqual(wp_long.hit_count, 1)
+
+        d.cont()
+
+        d.kill()
\ No newline at end of file
diff --git a/test/srcs/math_loop_test.c b/test/srcs/math_loop_test.c
new file mode 100644
index 00000000..918abb8e
--- /dev/null
+++ b/test/srcs/math_loop_test.c
@@ -0,0 +1,29 @@
+//
+// This file is part of libdebug Python library (https://github.com/libdebug/libdebug).
+// Copyright (c) 2024 Gabriele Digregorio. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+#include <stdio.h>
+#include <unistd.h>
+#include <math.h>
+
+int main() {
+    setvbuf(stdout, NULL, _IONBF, 0); 
+    setvbuf(stdin, NULL, _IONBF, 0);
+    setvbuf(stderr, NULL, _IONBF, 0);
+
+    double result;
+    int pid;
+
+    for (int i = 0; i < 1000; i++) {
+        // Perform a complex mathematical operation
+        result += sin(i) * log(i + 1) * sqrt(i + 1) + cos(i) / (i + 1);
+
+        // Call a harmless syscall
+        pid = getpid();
+        result += pid;
+    }
+
+    return 0;
+}
\ No newline at end of file