diff --git a/src/BB/log.jl b/src/BB/log.jl
index dc32805..81ca811 100644
--- a/src/BB/log.jl
+++ b/src/BB/log.jl
@@ -31,9 +31,9 @@ function print_progress(
     node::Node;
     time_elapsed::Float64,
     print_interval::Int,
-    primal_update::Bool,
+    primal_update::Bool
 )::Nothing
-    if (pool.processed % print_interval == 0) || isempty(pool.pending) || primal_update
+    if (pool.processed % print_interval == 0) || isempty(pool.pending)
         if isempty(node.branch_vars)
             branch_var_name = "---"
             branch_lb = "---"
diff --git a/src/BB/nodepool.jl b/src/BB/nodepool.jl
index a62a8b0..1882016 100644
--- a/src/BB/nodepool.jl
+++ b/src/BB/nodepool.jl
@@ -8,10 +8,10 @@ import Base.Threads: threadid
 
 function take(
     pool::NodePool;
-    suggestions::Array{Node} = [],
+    suggestions::Array{Node}=[],
     time_remaining::Float64,
     gap_limit::Float64,
-    node_limit::Int,
+    node_limit::Int
 )::Union{Symbol,Node}
     t = threadid()
     lock(pool.lock) do
@@ -53,8 +53,8 @@ function offer(
     pool::NodePool;
     parent_node::Union{Nothing,Node},
     child_nodes::Vector{Node},
-    time_elapsed::Float64 = 0.0,
-    print_interval::Int = 100,
+    time_elapsed::Float64=0.0,
+    print_interval::Int=100
 )::Nothing
     lock(pool.lock) do
         primal_update = false
@@ -101,30 +101,32 @@ function offer(
             # Update branching variable history
             branch_var = child_nodes[1].branch_vars[end]
             offset = findfirst(isequal(branch_var), parent_node.fractional_variables)
-            x = parent_node.fractional_values[offset]
-            obj_change_up = child_nodes[1].obj - parent_node.obj
-            obj_change_down = child_nodes[2].obj - parent_node.obj
-            _update_var_history(
-                pool = pool,
-                var = branch_var,
-                x = x,
-                obj_change_down = obj_change_down,
-                obj_change_up = obj_change_up,
-            )
-            # Update global history
-            pool.history.avg_pseudocost_up =
-                mean(vh.pseudocost_up for vh in values(pool.var_history))
-            pool.history.avg_pseudocost_down =
-                mean(vh.pseudocost_down for vh in values(pool.var_history))
+            if offset !== nothing
+                x = parent_node.fractional_values[offset]
+                obj_change_up = child_nodes[1].obj - parent_node.obj
+                obj_change_down = child_nodes[2].obj - parent_node.obj
+                _update_var_history(
+                    pool=pool,
+                    var=branch_var,
+                    x=x,
+                    obj_change_down=obj_change_down,
+                    obj_change_up=obj_change_up,
+                )
+                # Update global history
+                pool.history.avg_pseudocost_up =
+                    mean(vh.pseudocost_up for vh in values(pool.var_history))
+                pool.history.avg_pseudocost_down =
+                    mean(vh.pseudocost_down for vh in values(pool.var_history))
+            end
         end
 
         for node in child_nodes
             print_progress(
                 pool,
                 node,
-                time_elapsed = time_elapsed,
-                print_interval = print_interval,
-                primal_update = isfinite(node.obj) && isempty(node.fractional_variables),
+                time_elapsed=time_elapsed,
+                print_interval=print_interval,
+                primal_update=isfinite(node.obj) && isempty(node.fractional_variables),
             )
         end
     end
@@ -136,7 +138,7 @@ function _update_var_history(;
     var::Variable,
     x::Float64,
     obj_change_down::Float64,
-    obj_change_up::Float64,
+    obj_change_up::Float64
 )::Nothing
     # Create new history entry
     if var ∉ keys(pool.var_history)
diff --git a/src/BB/optimize.jl b/src/BB/optimize.jl
index fcdd020..4e05fc0 100644
--- a/src/BB/optimize.jl
+++ b/src/BB/optimize.jl
@@ -10,16 +10,22 @@ import ..H5File
 
 function solve!(
     mip::MIP;
-    time_limit::Float64 = Inf,
-    node_limit::Int = typemax(Int),
-    gap_limit::Float64 = 1e-4,
-    print_interval::Int = 5,
-    initial_primal_bound::Float64 = Inf,
-    branch_rule::VariableBranchingRule = ReliabilityBranching(),
-    enable_plunging = true,
-)::NodePool
+    time_limit::Float64=Inf,
+    node_limit::Int=typemax(Int),
+    gap_limit::Float64=1e-4,
+    print_interval::Int=5,
+    initial_primal_bound::Float64=Inf,
+    branch_rule::VariableBranchingRule=ReliabilityBranching(),
+    enable_plunging=true,
+    replay=nothing
+)::Tuple{NodePool,ReplayInfo}
+
+    if replay === nothing
+        replay = ReplayInfo()
+    end
+
     time_initial = time()
-    pool = NodePool(mip = mip)
+    pool = NodePool(mip=mip, next_index=replay.next_index)
     pool.primal_bound = initial_primal_bound
 
     root_node = _create_node(mip)
@@ -34,9 +40,9 @@ function solve!(
 
     offer(
         pool,
-        parent_node = nothing,
-        child_nodes = [root_node],
-        print_interval = print_interval,
+        parent_node=nothing,
+        child_nodes=[root_node],
+        print_interval=print_interval,
     )
     @threads for t = 1:nthreads()
         child_one, child_zero, suggestions = nothing, nothing, Node[]
@@ -47,10 +53,10 @@ function solve!(
             end
             node = take(
                 pool,
-                suggestions = suggestions,
-                time_remaining = time_limit - time_elapsed,
-                node_limit = node_limit,
-                gap_limit = gap_limit,
+                suggestions=suggestions,
+                time_remaining=time_limit - time_elapsed,
+                node_limit=node_limit,
+                gap_limit=gap_limit,
             )
             if node == :END
                 break
@@ -64,9 +70,24 @@ function solve!(
                 @assert status == :Optimal
                 _unset_node_bounds(node)
 
-                # Find branching variable
-                ids = generate_indices(pool, 2)
-                branch_var = find_branching_var(branch_rule, node, pool)
+                if node.index in keys(replay.node_decisions)
+                    decision = replay.node_decisions[node.index]
+                    ids = decision.ids
+                    branch_var = decision.branch_var
+                    var_value = decision.var_value
+                else
+                    # Find branching variable
+                    ids = generate_indices(pool, 2)
+                    branch_var = find_branching_var(branch_rule, node, pool)
+
+                    # Query current fractional value
+                    offset = findfirst(isequal(branch_var), node.fractional_variables)
+                    var_value = node.fractional_values[offset]
+
+                    # Update replay
+                    decision = ReplayNodeDecision(; branch_var, var_value, ids)
+                    replay.node_decisions[node.index] = decision
+                end
 
                 # Find current variable lower and upper bounds
                 offset = findfirst(isequal(branch_var), mip.int_vars)
@@ -79,46 +100,43 @@ function solve!(
                     end
                 end
 
-                # Query current fractional value
-                offset = findfirst(isequal(branch_var), node.fractional_variables)
-                var_value = node.fractional_values[offset]
-
                 child_zero = _create_node(
                     mip,
-                    index = ids[2],
-                    parent = node,
-                    branch_var = branch_var,
-                    branch_var_lb = var_lb,
-                    branch_var_ub = floor(var_value),
+                    index=ids[2],
+                    parent=node,
+                    branch_var=branch_var,
+                    branch_var_lb=var_lb,
+                    branch_var_ub=floor(var_value),
                 )
                 child_one = _create_node(
                     mip,
-                    index = ids[1],
-                    parent = node,
-                    branch_var = branch_var,
-                    branch_var_lb = ceil(var_value),
-                    branch_var_ub = var_ub,
+                    index=ids[1],
+                    parent=node,
+                    branch_var=branch_var,
+                    branch_var_lb=ceil(var_value),
+                    branch_var_ub=var_ub,
                 )
                 offer(
                     pool,
-                    parent_node = node,
-                    child_nodes = [child_one, child_zero],
-                    time_elapsed = time_elapsed,
-                    print_interval = print_interval,
+                    parent_node=node,
+                    child_nodes=[child_one, child_zero],
+                    time_elapsed=time_elapsed,
+                    print_interval=print_interval,
                 )
             end
         end
     end
-    return pool
+    replay.next_index = pool.next_index
+    return pool, replay
 end
 
 function _create_node(
     mip;
-    index::Int = 0,
-    parent::Union{Nothing,Node} = nothing,
-    branch_var::Union{Nothing,Variable} = nothing,
-    branch_var_lb::Union{Nothing,Float64} = nothing,
-    branch_var_ub::Union{Nothing,Float64} = nothing,
+    index::Int=0,
+    parent::Union{Nothing,Node}=nothing,
+    branch_var::Union{Nothing,Variable}=nothing,
+    branch_var_lb::Union{Nothing,Float64}=nothing,
+    branch_var_ub::Union{Nothing,Float64}=nothing
 )::Node
     if parent === nothing
         branch_vars = Variable[]
diff --git a/src/BB/structs.jl b/src/BB/structs.jl
index e3be2f8..9b450a8 100644
--- a/src/BB/structs.jl
+++ b/src/BB/structs.jl
@@ -72,3 +72,14 @@ Base.@kwdef mutable struct NodePool
     history::History = History()
     var_history::Dict{Variable,VariableHistory} = Dict()
 end
+
+Base.@kwdef struct ReplayNodeDecision
+    branch_var
+    var_value
+    ids
+end
+
+Base.@kwdef mutable struct ReplayInfo
+    node_decisions::Dict{Int,ReplayNodeDecision} = Dict()
+    next_index::Int = 1
+end
\ No newline at end of file
diff --git a/src/solvers/jump.jl b/src/solvers/jump.jl
index 726c449..56160bc 100644
--- a/src/solvers/jump.jl
+++ b/src/solvers/jump.jl
@@ -36,13 +36,14 @@ function _add_constrs(
 end
 
 function _extract_after_load(model::JuMP.Model, h5)
+    @info "_extract_after_load"
     if JuMP.objective_sense(model) == MOI.MIN_SENSE
         h5.put_scalar("static_sense", "min")
     else
         h5.put_scalar("static_sense", "max")
     end
-    _extract_after_load_vars(model, h5)
-    _extract_after_load_constrs(model, h5)
+    @time _extract_after_load_vars(model, h5)
+    @time _extract_after_load_constrs(model, h5)
 end
 
 function _extract_after_load_vars(model::JuMP.Model, h5)
@@ -117,10 +118,11 @@ function _extract_after_load_constrs(model::JuMP.Model, h5)
 end
 
 function _extract_after_lp(model::JuMP.Model, h5)
+    @info "_extract_after_lp"
     h5.put_scalar("lp_wallclock_time", solve_time(model))
     h5.put_scalar("lp_obj_value", objective_value(model))
-    _extract_after_lp_vars(model, h5)
-    _extract_after_lp_constrs(model, h5)
+    @time _extract_after_lp_vars(model, h5)
+    @time _extract_after_lp_constrs(model, h5)
 end
 
 function _extract_after_lp_vars(model::JuMP.Model, h5)
@@ -146,46 +148,46 @@ function _extract_after_lp_vars(model::JuMP.Model, h5)
     end
     h5.put_array("lp_var_basis_status", to_str_array(basis_status))
 
-    # Sensitivity analysis
-    obj_coeffs = h5.get_array("static_var_obj_coeffs")
-    sensitivity_report = lp_sensitivity_report(model)
-    sa_obj_down, sa_obj_up = Float64[], Float64[]
-    sa_lb_down, sa_lb_up = Float64[], Float64[]
-    sa_ub_down, sa_ub_up = Float64[], Float64[]
-    for (i, v) in enumerate(vars)
-        # Objective function
-        (delta_down, delta_up) = sensitivity_report[v]
-        push!(sa_obj_down, delta_down + obj_coeffs[i])
-        push!(sa_obj_up, delta_up + obj_coeffs[i])
-
-        # Lower bound
-        if has_lower_bound(v)
-            constr = LowerBoundRef(v)
-            (delta_down, delta_up) = sensitivity_report[constr]
-            push!(sa_lb_down, lower_bound(v) + delta_down)
-            push!(sa_lb_up, lower_bound(v) + delta_up)
-        else
-            push!(sa_lb_down, -Inf)
-            push!(sa_lb_up, -Inf)
-        end
-
-        # Upper bound
-        if has_upper_bound(v)
-            constr = JuMP.UpperBoundRef(v)
-            (delta_down, delta_up) = sensitivity_report[constr]
-            push!(sa_ub_down, upper_bound(v) + delta_down)
-            push!(sa_ub_up, upper_bound(v) + delta_up)
-        else
-            push!(sa_ub_down, Inf)
-            push!(sa_ub_up, Inf)
-        end
-    end
-    h5.put_array("lp_var_sa_obj_up", sa_obj_up)
-    h5.put_array("lp_var_sa_obj_down", sa_obj_down)
-    h5.put_array("lp_var_sa_ub_up", sa_ub_up)
-    h5.put_array("lp_var_sa_ub_down", sa_ub_down)
-    h5.put_array("lp_var_sa_lb_up", sa_lb_up)
-    h5.put_array("lp_var_sa_lb_down", sa_lb_down)
+    # # Sensitivity analysis
+    # obj_coeffs = h5.get_array("static_var_obj_coeffs")
+    # sensitivity_report = lp_sensitivity_report(model)
+    # sa_obj_down, sa_obj_up = Float64[], Float64[]
+    # sa_lb_down, sa_lb_up = Float64[], Float64[]
+    # sa_ub_down, sa_ub_up = Float64[], Float64[]
+    # for (i, v) in enumerate(vars)
+    #     # Objective function
+    #     (delta_down, delta_up) = sensitivity_report[v]
+    #     push!(sa_obj_down, delta_down + obj_coeffs[i])
+    #     push!(sa_obj_up, delta_up + obj_coeffs[i])
+
+    #     # Lower bound
+    #     if has_lower_bound(v)
+    #         constr = LowerBoundRef(v)
+    #         (delta_down, delta_up) = sensitivity_report[constr]
+    #         push!(sa_lb_down, lower_bound(v) + delta_down)
+    #         push!(sa_lb_up, lower_bound(v) + delta_up)
+    #     else
+    #         push!(sa_lb_down, -Inf)
+    #         push!(sa_lb_up, -Inf)
+    #     end
+
+    #     # Upper bound
+    #     if has_upper_bound(v)
+    #         constr = JuMP.UpperBoundRef(v)
+    #         (delta_down, delta_up) = sensitivity_report[constr]
+    #         push!(sa_ub_down, upper_bound(v) + delta_down)
+    #         push!(sa_ub_up, upper_bound(v) + delta_up)
+    #     else
+    #         push!(sa_ub_down, Inf)
+    #         push!(sa_ub_up, Inf)
+    #     end
+    # end
+    # h5.put_array("lp_var_sa_obj_up", sa_obj_up)
+    # h5.put_array("lp_var_sa_obj_down", sa_obj_down)
+    # h5.put_array("lp_var_sa_ub_up", sa_ub_up)
+    # h5.put_array("lp_var_sa_ub_down", sa_ub_down)
+    # h5.put_array("lp_var_sa_lb_up", sa_lb_up)
+    # h5.put_array("lp_var_sa_lb_down", sa_lb_down)
 end
 
 
@@ -201,7 +203,7 @@ function _extract_after_lp_constrs(model::JuMP.Model, h5)
     duals = Float64[]
     basis_status = []
     constr_idx = 1
-    sensitivity_report = lp_sensitivity_report(model)
+    # sensitivity_report = lp_sensitivity_report(model)
     for (ftype, stype) in JuMP.list_of_constraint_types(model)
         for constr in JuMP.all_constraints(model, ftype, stype)
             length(JuMP.name(constr)) > 0 || continue
@@ -219,21 +221,22 @@ function _extract_after_lp_constrs(model::JuMP.Model, h5)
                 error("Unknown basis status: $b")
             end
 
-            # Sensitivity analysis
-            (delta_down, delta_up) = sensitivity_report[constr]
-            push!(sa_rhs_down, rhs[constr_idx] + delta_down)
-            push!(sa_rhs_up, rhs[constr_idx] + delta_up)
+            # # Sensitivity analysis
+            # (delta_down, delta_up) = sensitivity_report[constr]
+            # push!(sa_rhs_down, rhs[constr_idx] + delta_down)
+            # push!(sa_rhs_up, rhs[constr_idx] + delta_up)
 
             constr_idx += 1
         end
     end
     h5.put_array("lp_constr_dual_values", duals)
     h5.put_array("lp_constr_basis_status", to_str_array(basis_status))
-    h5.put_array("lp_constr_sa_rhs_up", sa_rhs_up)
-    h5.put_array("lp_constr_sa_rhs_down", sa_rhs_down)
+    # h5.put_array("lp_constr_sa_rhs_up", sa_rhs_up)
+    # h5.put_array("lp_constr_sa_rhs_down", sa_rhs_down)
 end
 
 function _extract_after_mip(model::JuMP.Model, h5)
+    @info "_extract_after_mip"
     h5.put_scalar("mip_obj_value", objective_value(model))
     h5.put_scalar("mip_obj_bound", objective_bound(model))
     h5.put_scalar("mip_wallclock_time", solve_time(model))
@@ -254,11 +257,14 @@ end
 function _fix_variables(model::JuMP.Model, var_names, var_values, stats)
     vars = [variable_by_name(model, v) for v in var_names]
     for (i, var) in enumerate(vars)
-        fix(var, var_values[i], force = true)
+        if isfinite(var_values[i])
+            fix(var, var_values[i], force=true)
+        end
     end
 end
 
 function _optimize(model::JuMP.Model)
+    @info "_optimize"
     optimize!(model)
     flush(stdout)
     Libc.flush_cstdio()
@@ -269,7 +275,7 @@ function _relax(model::JuMP.Model)
     relax_integrality(relaxed)
     # FIXME: Remove hardcoded optimizer
     set_optimizer(relaxed, HiGHS.Optimizer)
-    set_silent(relaxed)
+    # set_silent(relaxed)
     return relaxed
 end
 
@@ -303,7 +309,7 @@ function __init_solvers_jump__()
             constrs_lhs,
             constrs_sense,
             constrs_rhs,
-            stats = nothing,
+            stats=nothing,
         ) = _add_constrs(
             self.inner,
             from_str_array(var_names),
@@ -319,14 +325,14 @@ function __init_solvers_jump__()
 
         extract_after_mip(self, h5) = _extract_after_mip(self.inner, h5)
 
-        fix_variables(self, var_names, var_values, stats = nothing) =
+        fix_variables(self, var_names, var_values, stats=nothing) =
             _fix_variables(self.inner, from_str_array(var_names), var_values, stats)
 
         optimize(self) = _optimize(self.inner)
 
         relax(self) = Class(_relax(self.inner))
 
-        set_warm_starts(self, var_names, var_values, stats = nothing) =
+        set_warm_starts(self, var_names, var_values, stats=nothing) =
             _set_warm_starts(self.inner, from_str_array(var_names), var_values, stats)
 
         write(self, filename) = _write(self.inner, filename)
diff --git a/test/Project.toml b/test/Project.toml
index dce63f3..9987a59 100644
--- a/test/Project.toml
+++ b/test/Project.toml
@@ -4,7 +4,9 @@ authors = ["Alinson S. Xavier <git@axavier.org>"]
 version = "0.1.0"
 
 [deps]
+CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
 Clp = "e2554f3b-3117-50c0-817c-e040a3ddf72d"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 Glob = "c27321d9-0574-5035-807b-f59d2c89b15c"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 HiGHS = "87dc4568-4c63-4d18-b0c0-bb2238e4078b"
diff --git a/test/fixtures/stab/stab-n190-00000.h5 b/test/fixtures/stab/stab-n190-00000.h5
new file mode 100644
index 0000000..c70823b
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00000.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00000.mps.gz b/test/fixtures/stab/stab-n190-00000.mps.gz
new file mode 100644
index 0000000..d270669
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00000.mps.gz differ
diff --git a/test/fixtures/stab/stab-n190-00002.h5 b/test/fixtures/stab/stab-n190-00002.h5
new file mode 100644
index 0000000..31bfc37
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00002.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00002.mps.gz b/test/fixtures/stab/stab-n190-00002.mps.gz
new file mode 100644
index 0000000..cf82554
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00002.mps.gz differ
diff --git a/test/fixtures/stab/stab-n190-00003.h5 b/test/fixtures/stab/stab-n190-00003.h5
new file mode 100644
index 0000000..cfc852e
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00003.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00003.mps.gz b/test/fixtures/stab/stab-n190-00003.mps.gz
new file mode 100644
index 0000000..bf50673
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00003.mps.gz differ
diff --git a/test/fixtures/stab/stab-n190-00004.h5 b/test/fixtures/stab/stab-n190-00004.h5
new file mode 100644
index 0000000..60e3da9
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00004.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00004.mps.gz b/test/fixtures/stab/stab-n190-00004.mps.gz
new file mode 100644
index 0000000..db7fd37
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00004.mps.gz differ
diff --git a/test/fixtures/stab/stab-n190-00005.h5 b/test/fixtures/stab/stab-n190-00005.h5
new file mode 100644
index 0000000..855899b
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00005.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00005.mps.gz b/test/fixtures/stab/stab-n190-00005.mps.gz
new file mode 100644
index 0000000..420e516
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00005.mps.gz differ
diff --git a/test/fixtures/stab/stab-n190-00006.h5 b/test/fixtures/stab/stab-n190-00006.h5
new file mode 100644
index 0000000..1ad8c56
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00006.h5 differ
diff --git a/test/fixtures/stab/stab-n190-00006.mps.gz b/test/fixtures/stab/stab-n190-00006.mps.gz
new file mode 100644
index 0000000..d25ce78
Binary files /dev/null and b/test/fixtures/stab/stab-n190-00006.mps.gz differ
diff --git a/test/src/BB/tables.ipynb b/test/src/BB/tables.ipynb
new file mode 100644
index 0000000..4a03a8f
--- /dev/null
+++ b/test/src/BB/tables.ipynb
@@ -0,0 +1,284 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "d50e05d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%config InlineBackend.figure_format = \"retina\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "3992d7bb-a88c-4c93-97fc-f5336fdc1b61",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from glob import glob\n",
+    "import numpy as np\n",
+    "\n",
+    "sns.set()\n",
+    "sns.set_palette(\n",
+    "    [\n",
+    "        \"#9b59b6\",\n",
+    "        \"#3498db\",\n",
+    "        \"#95a5a6\",\n",
+    "        \"#e74c3c\",\n",
+    "        \"#34495e\",\n",
+    "        \"#2ecc71\",\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def _read_csv(pattern):\n",
+    "    results = []\n",
+    "    for filename in sorted(glob(pattern)):\n",
+    "        group_df = pd.read_csv(filename)\n",
+    "        results.append(group_df)\n",
+    "    return pd.concat(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "40266100-96db-40ef-bfde-a333eec685b5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Solve time (s)</th>\n",
+       "      <th>Relative MIP gap (%)</th>\n",
+       "      <th>Filename</th>\n",
+       "      <th>Replay?</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>60.334876</td>\n",
+       "      <td>10.367</td>\n",
+       "      <td>stab-n190-00002</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>22.362843</td>\n",
+       "      <td>10.624</td>\n",
+       "      <td>stab-n190-00002</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>64.175137</td>\n",
+       "      <td>11.990</td>\n",
+       "      <td>stab-n190-00003</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>9.832989</td>\n",
+       "      <td>12.019</td>\n",
+       "      <td>stab-n190-00003</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>62.089274</td>\n",
+       "      <td>12.094</td>\n",
+       "      <td>stab-n190-00004</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11.317094</td>\n",
+       "      <td>12.231</td>\n",
+       "      <td>stab-n190-00004</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>62.538222</td>\n",
+       "      <td>11.530</td>\n",
+       "      <td>stab-n190-00005</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>17.388693</td>\n",
+       "      <td>11.610</td>\n",
+       "      <td>stab-n190-00005</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>63.194424</td>\n",
+       "      <td>10.384</td>\n",
+       "      <td>stab-n190-00006</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>21.746949</td>\n",
+       "      <td>10.363</td>\n",
+       "      <td>stab-n190-00006</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Solve time (s)  Relative MIP gap (%)         Filename  Replay?\n",
+       "0       60.334876                10.367  stab-n190-00002    False\n",
+       "1       22.362843                10.624  stab-n190-00002     True\n",
+       "2       64.175137                11.990  stab-n190-00003    False\n",
+       "3        9.832989                12.019  stab-n190-00003     True\n",
+       "4       62.089274                12.094  stab-n190-00004    False\n",
+       "5       11.317094                12.231  stab-n190-00004     True\n",
+       "6       62.538222                11.530  stab-n190-00005    False\n",
+       "7       17.388693                11.610  stab-n190-00005     True\n",
+       "8       63.194424                10.384  stab-n190-00006    False\n",
+       "9       21.746949                10.363  stab-n190-00006     True"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data = _read_csv(\"../../../tmp.csv\")\n",
+    "data[\"Filename\"] = data[\"Filename\"].str.replace(\"test/fixtures/stab/\", \"\")\n",
+    "data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "39381cac",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='Relative MIP gap (%)', ylabel='Filename'>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 593,
+       "width": 693
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hue_order = [False, True]\n",
+    "palette = {\n",
+    "    False: \"#9E9E9E\",\n",
+    "    True: \"#6A1B9A\",\n",
+    "}\n",
+    "\n",
+    "(fig, (ax1, ax2)) = plt.subplots(\n",
+    "    1,\n",
+    "    2,\n",
+    "    figsize=(10, 10),\n",
+    "    sharey=True,\n",
+    ")\n",
+    "\n",
+    "sns.barplot(\n",
+    "    x=\"Solve time (s)\",\n",
+    "    y=\"Filename\",\n",
+    "    hue=\"Replay?\",\n",
+    "    data=data,\n",
+    "    ax=ax1,\n",
+    "    hue_order=hue_order,\n",
+    "    palette=[palette[h] for h in hue_order],\n",
+    ")\n",
+    "\n",
+    "sns.barplot(\n",
+    "    x=\"Relative MIP gap (%)\",\n",
+    "    y=\"Filename\",\n",
+    "    hue=\"Replay?\",\n",
+    "    data=data,\n",
+    "    ax=ax2,\n",
+    "    hue_order=hue_order,\n",
+    "    palette=[palette[h] for h in hue_order],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "742c329d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test/src/BB/test_bb.jl b/test/src/BB/test_bb.jl
index cf51bc7..7946e24 100644
--- a/test/src/BB/test_bb.jl
+++ b/test/src/BB/test_bb.jl
@@ -10,9 +10,12 @@ using Test
 using MIPLearn.BB
 using MIPLearn
 
+using CSV
+using DataFrames
+
 basepath = @__DIR__
 
-function bb_run(optimizer_name, optimizer; large = true)
+function bb_run(optimizer_name, optimizer; large=true)
     @testset "Solve ($optimizer_name)" begin
         @testset "interface" begin
             filename = "$FIXTURES/danoint.mps.gz"
@@ -25,7 +28,7 @@ function bb_run(optimizer_name, optimizer; large = true)
 
             status, obj = BB.solve_relaxation!(mip)
             @test status == :Optimal
-            @test round(obj, digits = 6) == 62.637280
+            @test round(obj, digits=6) == 62.637280
 
             @test BB.name(mip, mip.int_vars[1]) == "xab"
             @test BB.name(mip, mip.int_vars[2]) == "xac"
@@ -35,26 +38,26 @@ function bb_run(optimizer_name, optimizer; large = true)
             @test mip.int_vars_ub[1] == 1.0
 
             vals = BB.values(mip, mip.int_vars)
-            @test round(vals[1], digits = 6) == 0.046933
-            @test round(vals[2], digits = 6) == 0.000841
-            @test round(vals[3], digits = 6) == 0.248696
+            @test round(vals[1], digits=6) == 0.046933
+            @test round(vals[2], digits=6) == 0.000841
+            @test round(vals[3], digits=6) == 0.248696
 
             # Probe (up and down are feasible)
             probe_up, probe_down = BB.probe(mip, mip.int_vars[1], 0.5, 0.0, 1.0, 1_000_000)
-            @test round(probe_down, digits = 6) == 62.690000
-            @test round(probe_up, digits = 6) == 62.714100
+            @test round(probe_down, digits=6) == 62.690000
+            @test round(probe_up, digits=6) == 62.714100
 
             # Fix one variable to zero
             BB.set_bounds!(mip, mip.int_vars[1:1], [0.0], [0.0])
             status, obj = BB.solve_relaxation!(mip)
             @test status == :Optimal
-            @test round(obj, digits = 6) == 62.690000
+            @test round(obj, digits=6) == 62.690000
 
             # Fix one variable to one and another variable variable to zero
             BB.set_bounds!(mip, mip.int_vars[1:2], [1.0, 0.0], [1.0, 0.0])
             status, obj = BB.solve_relaxation!(mip)
             @test status == :Optimal
-            @test round(obj, digits = 6) == 62.714777
+            @test round(obj, digits=6) == 62.714777
 
             # Fix all binary variables to one, making problem infeasible
             N = length(mip.int_vars)
@@ -68,7 +71,7 @@ function bb_run(optimizer_name, optimizer; large = true)
             BB.set_bounds!(mip, mip.int_vars, zeros(N), ones(N))
             status, obj = BB.solve_relaxation!(mip)
             @test status == :Optimal
-            @test round(obj, digits = 6) == 62.637280
+            @test round(obj, digits=6) == 62.637280
         end
 
         @testset "varbranch" begin
@@ -82,8 +85,8 @@ function bb_run(optimizer_name, optimizer; large = true)
                     BB.StrongBranching(),
                     BB.ReliabilityBranching(),
                     BB.HybridBranching(),
-                    BB.StrongBranching(aggregation = :min),
-                    BB.ReliabilityBranching(aggregation = :min, collect = true),
+                    BB.StrongBranching(aggregation=:min),
+                    BB.ReliabilityBranching(aggregation=:min, collect=true),
                 ]
                     h5 = H5File("$FIXTURES/$instance.h5")
                     mip_lower_bound = h5.get_scalar("mip_lower_bound")
@@ -98,23 +101,23 @@ function bb_run(optimizer_name, optimizer; large = true)
                     @info optimizer_name, branch_rule, instance
                     @time BB.solve!(
                         mip,
-                        initial_primal_bound = mip_primal_bound,
-                        print_interval = 1,
-                        node_limit = 25,
-                        branch_rule = branch_rule,
+                        initial_primal_bound=mip_primal_bound,
+                        print_interval=1,
+                        node_limit=25,
+                        branch_rule=branch_rule,
                     )
                 end
             end
         end
 
         @testset "collect" begin
-            rule = BB.ReliabilityBranching(collect = true)
+            rule = BB.ReliabilityBranching(collect=true)
             BB.collect!(
                 optimizer,
                 "$FIXTURES/bell5.mps.gz",
-                node_limit = 100,
-                print_interval = 10,
-                branch_rule = rule,
+                node_limit=100,
+                print_interval=10,
+                branch_rule=rule,
             )
             n_sb = rule.stats.num_strong_branch_calls
             h5 = H5File("$FIXTURES/bell5.h5")
@@ -132,3 +135,67 @@ function test_bb()
     @time bb_run("HiGHS", optimizer_with_attributes(HiGHS.Optimizer))
     # @time bb_run("CPLEX", optimizer_with_attributes(CPLEX.Optimizer, "CPXPARAM_Threads" => 1))
 end
+
+function test_bb_replay()
+    rule_sb = BB.StrongBranching()
+    rule_rb = BB.ReliabilityBranching()
+    optimizer = optimizer_with_attributes(HiGHS.Optimizer)
+    filenames = [replace(f, ".h5" => "") for f in glob("test/fixtures/stab/*.h5")]
+    results_filename = "tmp.csv"
+
+    lk = ReentrantLock()
+    results = []
+
+    function push_result(r)
+        lock(lk) do
+            push!(results, r)
+            df = DataFrame()
+            for row in results
+                push!(df, row, cols=:union)
+            end
+            CSV.write(results_filename, df)
+        end
+    end
+
+    function solve(filename; replay=nothing, skip=false, rule)
+        has_replay = (replay !== nothing)
+        h5 = H5File("$filename.h5", "r")
+        mip_obj_bound = h5.get_scalar("mip_obj_bound")
+        @show filename
+        @show has_replay
+        h5.file.close()
+        mip = BB.init(optimizer)
+        BB.read!(mip, "$filename.mps.gz")
+        time_solve = @elapsed begin
+            pool, replay = BB.solve!(
+                mip,
+                initial_primal_bound=mip_obj_bound,
+                print_interval=100,
+                node_limit=1_000,
+                branch_rule=rule,
+                replay=replay,
+            )
+        end
+        if !skip
+            push_result(
+                Dict(
+                    "Filename" => filename,
+                    "Replay?" => has_replay,
+                    "Solve time (s)" => time_solve,
+                    "Relative MIP gap (%)" => round(pool.gap * 100, digits=3)
+                )
+            )
+        end
+        return replay
+    end
+
+    # Solve reference instance
+    replay = solve(filenames[1], skip=true, rule=rule_sb)
+
+    # Solve perturbations
+    for i in 2:6
+        solve(filenames[i], rule=rule_rb, replay=nothing)
+        solve(filenames[i], rule=rule_rb, replay=deepcopy(replay))
+    end
+    return
+end
\ No newline at end of file