diff --git a/analysis/fidelity_constraint/bqc_nv_constraint.py b/analysis/fidelity_constraint/bqc_nv_constraint.py
new file mode 100644
index 00000000..64fd2fbf
--- /dev/null
+++ b/analysis/fidelity_constraint/bqc_nv_constraint.py
@@ -0,0 +1,653 @@
+from __future__ import annotations
+
+import datetime
+import json
+import math
+import os
+import random
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, Dict, Generator, List, Optional
+
+import matplotlib.pyplot as plt
+import netsquid as ns
+from netqasm.lang.ir import BreakpointAction
+from netqasm.sdk.connection import BaseNetQASMConnection
+from netqasm.sdk.futures import Future, RegFuture
+from netqasm.sdk.qubit import Qubit
+
+from pydynaa import EventExpression
+from squidasm.run.stack.config import NVQDeviceConfig, StackNetworkConfig
+from squidasm.run.stack.run import run
+from squidasm.sim.stack.common import LogManager, SubroutineAbortedError
+from squidasm.sim.stack.csocket import ClassicalSocket
+from squidasm.sim.stack.globals import GlobalSimData
+from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
+
+
+class CompileVersion(Enum):
+    NETQASM_RETRY = 0
+    HOST_RETRY = 1
+    NO_RETRY = 2
+
+
+COMPILE_VERSIONS = ["nqasm_retry", "host_retry"]
+FORMATS = {
+    "nqasm_retry": "-ro",
+    "host_retry": "-bs",
+    "no_retry": "-gs",
+}
+FORMATS_2 = {
+    "nqasm_retry": "--ro",
+    "host_retry": "--bo",
+    "no_retry": "--go",
+}
+VERSION_LABELS = {
+    "nqasm_retry": "NetQASM retry",
+    "host_retry": "Host retry",
+    "no_retry": "No retry",
+}
+
+X_LABELS = {
+    "host_qnos_latency_duration": "Host <-> QNodeOS latency (ms)",
+    "host_qnos_latency_error_rate": "Host <-> QNodeOS latency (ms)",
+}
+
+MAX_TRIES = 1000
+MAX_TRIES_ABORT = 1000
+
+
+class ClientProgram(Program):
+    PEER = "server"
+
+    def __init__(
+        self,
+        alpha: float,
+        beta: float,
+        trap: bool,
+        dummy: int,
+        theta1: float,
+        theta2: float,
+        r1: int,
+        r2: int,
+        compile_version: CompileVersion = CompileVersion.NO_RETRY,
+    ):
+        self._alpha = alpha
+        self._beta = beta
+        self._trap = trap
+        self._dummy = dummy
+        self._theta1 = theta1
+        self._theta2 = theta2
+        self._r1 = r1
+        self._r2 = r2
+        self._compile_version = compile_version
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="client_program",
+            parameters={
+                "alpha": self._alpha,
+                "beta": self._beta,
+                "trap": self._trap,
+                "dummy": self._dummy,
+                "theta1": self._theta1,
+                "theta2": self._theta2,
+                "r1": self._r1,
+                "r2": self._r2,
+                "compile_version": self._compile_version,
+            },
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=2,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        conn = context.connection
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+
+        GlobalSimData.reset_custom_event_count("EPR attempt")
+
+        p1: Future
+        p2: Future
+        outcomes = conn.new_array(length=2)
+
+        def post_create(_: BaseNetQASMConnection, q: Qubit, index: RegFuture):
+            with index.if_eq(0):
+                if not (self._trap and self._dummy == 2):
+                    q.rot_Z(angle=self._theta2)
+                    q.H()
+
+            with index.if_eq(1):
+                if not (self._trap and self._dummy == 1):
+                    q.rot_Z(angle=self._theta1)
+                    q.H()
+            q.measure(future=outcomes.get_future_index(index))
+
+        if self._compile_version == CompileVersion.NETQASM_RETRY:
+            epr_socket.create_keep(
+                2,
+                sequential=True,
+                post_routine=post_create,
+                min_fidelity_all_at_end=90,
+                max_tries=MAX_TRIES,
+            )
+            yield from conn.flush()
+        elif self._compile_version == CompileVersion.HOST_RETRY:
+            max_tries = MAX_TRIES_ABORT
+            for count in range(max_tries):
+                try:
+                    epr_socket.create_keep(
+                        2, sequential=True, post_routine=post_create, max_time=10_000
+                    )
+                    yield from conn.flush()
+                except SubroutineAbortedError:
+                    if count == max_tries - 1:
+                        raise RuntimeError(f"failed {max_tries} times, aborting.")
+                    else:
+                        conn.builder._reset()
+                        conn.builder._mem_mgr.inactivate_qubits()
+                        continue  # try again
+                else:  # subroutine successfully executed
+                    print(f"succeeded after {count + 1} times")
+                    break
+
+        else:
+            epr_socket.create_keep(2, sequential=True, post_routine=post_create)
+            yield from conn.flush()
+
+        p1 = int(outcomes.get_future_index(1))
+        p2 = int(outcomes.get_future_index(0))
+
+        if self._trap and self._dummy == 2:
+            delta1 = -self._theta1 + (p1 + self._r1) * math.pi
+        else:
+            delta1 = self._alpha - self._theta1 + (p1 + self._r1) * math.pi
+        csocket.send_float(delta1)
+
+        m1 = yield from csocket.recv_int()
+        if self._trap and self._dummy == 1:
+            delta2 = -self._theta2 + (p2 + self._r2) * math.pi
+        else:
+            delta2 = (
+                math.pow(-1, (m1 + self._r1)) * self._beta
+                - self._theta2
+                + (p2 + self._r2) * math.pi
+            )
+        csocket.send_float(delta2)
+
+        attempt_count = GlobalSimData.get_custom_event_count("EPR attempt")
+        print(f"attempt count: {attempt_count}")
+
+        return {"p1": p1, "p2": p2, "attempts": attempt_count}
+
+
+class ServerProgram(Program):
+    PEER = "client"
+
+    def __init__(
+        self, compile_version: CompileVersion = CompileVersion.NO_RETRY
+    ) -> None:
+        self._compile_version = compile_version
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="server_program",
+            parameters={"compile_version": self._compile_version},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=2,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        conn = context.connection
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+
+        start = ns.sim_time()
+
+        if self._compile_version == CompileVersion.NETQASM_RETRY:
+            epr1, epr2 = epr_socket.recv_keep(
+                2,
+                min_fidelity_all_at_end=90,
+                max_tries=MAX_TRIES,
+            )
+            epr2.cphase(epr1)
+
+            yield from conn.flush()
+        elif self._compile_version == CompileVersion.HOST_RETRY:
+            max_tries = MAX_TRIES_ABORT
+            for count in range(max_tries):
+                try:
+                    epr1, epr2 = epr_socket.recv_keep(2)
+                    epr2.cphase(epr1)
+                    yield from conn.flush()
+                except SubroutineAbortedError:
+                    if count == max_tries - 1:
+                        raise RuntimeError(f"failed {max_tries} times, aborting.")
+                    else:
+                        conn.builder._reset()
+                        conn.builder._mem_mgr.inactivate_qubits()
+                        continue  # try again
+                else:  # subroutine successfully executed
+                    break
+        else:
+            epr1, epr2 = epr_socket.recv_keep(2)
+            epr2.cphase(epr1)
+            yield from conn.flush()
+
+        delta1 = yield from csocket.recv_float()
+
+        epr2.rot_Z(angle=delta1)
+        epr2.H()
+        m1 = epr2.measure(store_array=False)
+        yield from conn.flush()
+
+        m1 = int(m1)
+
+        csocket.send_int(m1)
+
+        delta2 = yield from csocket.recv_float()
+
+        epr1.rot_Z(angle=delta2)
+        epr1.H()
+        conn.insert_breakpoint(BreakpointAction.DUMP_LOCAL_STATE)
+        m2 = epr1.measure(store_array=False)
+        yield from conn.flush()
+
+        m2 = int(m2)
+
+        end = ns.sim_time()
+        return {"m1": m1, "m2": m2, "duration": (end - start)}
+
+
+PI = math.pi
+PI_OVER_2 = math.pi / 2
+
+
+def computation_round(
+    cfg: StackNetworkConfig,
+    num_times: int = 1,
+    alpha: float = 0.0,
+    beta: float = 0.0,
+    theta1: float = 0.0,
+    theta2: float = 0.0,
+) -> None:
+    client_program = ClientProgram(
+        alpha=alpha,
+        beta=beta,
+        trap=False,
+        dummy=-1,
+        theta1=theta1,
+        theta2=theta2,
+        r1=0,
+        r2=0,
+    )
+    server_program = ServerProgram()
+
+    _, server_results = run(
+        cfg, {"client": client_program, "server": server_program}, num_times=num_times
+    )
+
+    m2s = [result["m2"] for result in server_results]
+    num_zeros = len([m for m in m2s if m == 0])
+    frac0 = round(num_zeros / num_times, 2)
+    frac1 = 1 - frac0
+    print(f"dist (0, 1) = ({frac0}, {frac1})")
+
+
+def trap_round(
+    cfg: StackNetworkConfig,
+    num_times: int = 1,
+    alpha: float = 0.0,
+    beta: float = 0.0,
+    theta1: float = 0.0,
+    theta2: float = 0.0,
+    dummy: int = 1,
+    compile_version: CompileVersion = CompileVersion.NO_RETRY,
+    use_random_inputs: bool = False,
+) -> SimulationOutput:
+    if use_random_inputs:
+        alpha = random.uniform(-PI, PI)
+        beta = random.uniform(-PI, PI)
+        theta1 = random.uniform(-PI, PI)
+        theta2 = random.uniform(-PI, PI)
+        dummy = random.randrange(1, 3)
+
+    client_program = ClientProgram(
+        alpha=alpha,
+        beta=beta,
+        trap=True,
+        dummy=dummy,
+        theta1=theta1,
+        theta2=theta2,
+        r1=0,
+        r2=0,
+        compile_version=compile_version,
+    )
+    server_program = ServerProgram(compile_version=compile_version)
+
+    client_results, server_results = run(
+        cfg, {"client": client_program, "server": server_program}, num_times=num_times
+    )
+
+    p1s = [result["p1"] for result in client_results]
+    p2s = [result["p2"] for result in client_results]
+    m1s = [result["m1"] for result in server_results]
+    m2s = [result["m2"] for result in server_results]
+
+    assert dummy in [1, 2]
+    if dummy == 1:
+        num_fails = len([(p, m) for (p, m) in zip(p1s, m2s) if p != m])
+    else:
+        num_fails = len([(p, m) for (p, m) in zip(p2s, m1s) if p != m])
+
+    frac_fail = round(num_fails / num_times, 2)
+    # print(f"fail rate: {frac_fail}")
+    succ_rate_metric = SuccessRate(
+        "success", num_succ=(num_times - num_fails), num_times=num_times
+    )
+
+    durations = [result["duration"] for result in server_results]
+    duration_metric = Metric("duration", durations)
+
+    attempts = [result["attempts"] for result in client_results]
+    attempt_count_metric = Metric("attempt_count", attempts)
+
+    return SimulationOutput(
+        # error_rate=frac_fail,
+        succ_rate=succ_rate_metric,
+        duration=duration_metric,
+        attempt_count=attempt_count_metric,
+    )
+
+
+class SuccessRate:
+    def __init__(self, name: str, num_succ: int, num_times: int) -> None:
+        self._name = name
+        self._num_succ = num_succ
+        self._num_times = num_times
+
+    @property
+    def success_rate(self) -> float:
+        return self._num_succ / self._num_times
+
+    @property
+    def fail_rate(self) -> float:
+        return 1 - self.success_rate
+
+    @property
+    def confidence_interval_95(self) -> float:
+        p = self.success_rate
+        n = self._num_times
+        return 1.96 * math.sqrt(p * (1 - p) / n)
+
+    def serialize(self) -> Dict:
+        return {
+            "success_rate": self.success_rate,
+            "conf_95": self.confidence_interval_95,
+        }
+
+
+class Metric:
+    def __init__(self, name: str, data: List[Any]) -> None:
+        self._name = name
+        self._data = data
+
+        self._mean: Optional[float] = None
+        self._std_error: Optional[float] = None
+
+    @property
+    def size(self) -> int:
+        return len(self._data)
+
+    @property
+    def data(self) -> List[Any]:
+        return self._data
+
+    @property
+    def mean(self) -> float:
+        if self._mean is None:
+            self._mean = sum(self._data) / self.size
+        return self._mean
+
+    @property
+    def std_error(self) -> float:
+        if self._std_error is None:
+            variance = (
+                sum((d - self.mean) * (d - self.mean) for d in self.data) / self.size
+            )
+            self._std_error = math.sqrt(variance) / math.sqrt(self.size)
+        return self._std_error
+
+    def serialize(self) -> Dict:
+        return {"mean": self.mean, "std_error": self.std_error}
+
+
+@dataclass
+class SimulationInput:
+    fidelity: float
+    prob_success: float
+    host_qnos_latency: float
+    t2_time: float
+    compile_version: CompileVersion
+
+
+@dataclass
+class SimulationMeta:
+    num_times: int
+    sweep_variable: str
+    metrics: List[str]
+
+
+@dataclass
+class SimulationOutput:
+    succ_rate: SuccessRate
+    duration: Metric
+    attempt_count: Metric
+
+    def serialize(self) -> Dict:
+        return {
+            "succ_rate": self.succ_rate.serialize(),
+            "duration": self.duration.serialize(),
+            "attempt_coutn": self.attempt_count.serialize(),
+        }
+
+
+def simulate(
+    input: SimulationInput, meta: SimulationMeta
+) -> Dict[float, SimulationOutput]:
+    start = ns.sim_time()
+
+    GlobalSimData.create_custom_event_type("EPR attempt")
+
+    results: Dict[float, SimulationOutput] = {}
+
+    # for latency in range(int(1e6), int(10e6), int(4e6)):
+    for latency in range(int(1e6), int(10e6), int(1e6)):
+
+        cfg.links[0].cfg["fidelity"] = input.fidelity
+        cfg.links[0].cfg["prob_success"] = input.prob_success
+        cfg.stacks[0].host_qnos_latency = latency
+        cfg.stacks[1].host_qnos_latency = latency
+        cfg.stacks[0].qdevice_cfg.electron_T2 = input.t2_time
+        cfg.stacks[0].qdevice_cfg.carbon_T2 = input.t2_time
+        cfg.stacks[1].qdevice_cfg.electron_T2 = input.t2_time
+        cfg.stacks[1].qdevice_cfg.carbon_T2 = input.t2_time
+
+        output = trap_round(
+            cfg=cfg,
+            num_times=meta.num_times,
+            compile_version=input.compile_version,
+            use_random_inputs=True,
+        )
+        results[latency] = output
+
+        print(f"simulated time: {ns.sim_time() - start}")
+
+        # print(output)
+        dur_mean = round(output.duration.mean, 3)
+        dur_err = round(output.duration.std_error, 3)
+        att_mean = round(output.attempt_count.mean, 3)
+        att_err = round(output.attempt_count.std_error, 3)
+
+        print("RESULTS\n")
+        print(f"error rate  : {1 - output.succ_rate.success_rate}")
+        print(f"duration    : {dur_mean} (+/- {dur_err})")
+        print(f"num attempts: {att_mean} (+/- {att_err})")
+
+    GlobalSimData.remove_custom_event_type("EPR attempt")
+
+    return results
+
+
+def create_png(param_name):
+    output_dir = os.path.join(os.path.dirname(__file__), "plots")
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_path = os.path.join(output_dir, f"bqc_sweep_{param_name}_{timestamp}.png")
+    plt.savefig(output_path)
+    print(f"plot written to {output_path}")
+
+
+def plot_host_qnos_latency_duration(
+    data_nqasm_retry: Dict[float, SimulationOutput],
+    data_host_retry: Dict[float, SimulationOutput],
+    data_no_retry: Dict[float, SimulationOutput],
+):
+    param_name = "host_qnos_latency_duration"
+    fig, ax = plt.subplots()
+    ax.grid()
+    ax.set_xlabel(X_LABELS[param_name])
+    ax.set_ylabel("Duration")
+
+    for compile_type in ["nqasm_retry", "host_retry", "no_retry"]:
+        if compile_type == "nqasm_retry":
+            data = data_nqasm_retry
+        elif compile_type == "host_retry":
+            data = data_host_retry
+        else:
+            data = data_no_retry
+
+        sweep_values = [v / 1e6 for v in data.keys()]
+        means = [v.duration.mean for v in data.values()]
+        std_errs = [v.duration.std_error for v in data.values()]
+        ax.errorbar(
+            x=sweep_values,
+            y=means,
+            yerr=std_errs,
+            fmt=FORMATS[compile_type],
+            label=VERSION_LABELS[compile_type],
+        )
+
+    ax.set_title("Duration", wrap=True)
+    ax.legend()
+    create_png(param_name)
+
+
+def plot_host_qnos_latency_error_rate(
+    data_nqasm_retry: Dict[float, SimulationOutput],
+    data_host_retry: Dict[float, SimulationOutput],
+    data_no_retry: Dict[float, SimulationOutput],
+):
+    param_name = "host_qnos_latency_error_rate"
+    fig, ax = plt.subplots()
+    ax.grid()
+    ax.set_xlabel(X_LABELS[param_name])
+    ax.set_ylabel("Error rate")
+
+    # for compile_type in ["nqasm_retry", "host_retry", "no_retry"]:
+    for compile_type in ["nqasm_retry", "no_retry"]:
+        if compile_type == "nqasm_retry":
+            data = data_nqasm_retry
+        elif compile_type == "host_retry":
+            data = data_host_retry
+        else:
+            data = data_no_retry
+
+        sweep_values = [v / 1e6 for v in data.keys()]
+        error_rates = [(1 - v.succ_rate.success_rate) for v in data.values()]
+        std_errs = [v.succ_rate.confidence_interval_95 for v in data.values()]
+        ax.errorbar(
+            x=sweep_values,
+            y=error_rates,
+            yerr=std_errs,
+            fmt=FORMATS[compile_type],
+            label=VERSION_LABELS[compile_type],
+        )
+
+    ax.set_title("Error rate", wrap=True)
+    ax.legend()
+    create_png(param_name)
+
+
+def dump_data(data: Any, param_name: str) -> None:
+    output_dir = os.path.join(os.path.dirname(__file__), "sweep_data_bqc")
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    with open(os.path.join(output_dir, f"{param_name}_{timestamp}.json"), "w") as f:
+        json.dump(data, f)
+
+
+if __name__ == "__main__":
+    LogManager.set_log_level("WARNING")
+
+    dump_file = os.path.join(os.path.dirname(__file__), "dump_bqc_nv_constraint.log")
+    LogManager.log_to_file(dump_file)
+    ns.set_qstate_formalism(ns.qubits.qformalism.QFormalism.DM)
+
+    cfg_file = os.path.join(os.path.dirname(__file__), "config_nv.yaml")
+    cfg = StackNetworkConfig.from_file(cfg_file)
+    cfg.stacks[0].qdevice_cfg = NVQDeviceConfig.perfect_config()
+    cfg.stacks[1].qdevice_cfg = NVQDeviceConfig.perfect_config()
+
+    input = SimulationInput(
+        fidelity=0.9,
+        prob_success=0.9,
+        host_qnos_latency=10e6,
+        t2_time=1e8,
+        compile_version=CompileVersion.HOST_RETRY,
+    )
+
+    # cfg.links[0].cfg["fidelity"] = 0.9
+    # # cfg.links[0].cfg["prob_success"] = 50.0e-5
+    # cfg.links[0].cfg["prob_success"] = 1
+    # # cfg.links[0].cfg["t_cycle"] = 50000
+    # GlobalSimData.create_custom_event_type("EPR attempt")
+    # result = trap_round(cfg, num_times=50, compile_version=CompileVersion.NETQASM_RETRY)
+    # print(f"error rate: {1 - result.succ_rate.success_rate}")
+
+    # exit()
+
+    meta = SimulationMeta(
+        num_times=500, sweep_variable="host_qnos_latency", metrics=["duration"]
+    )
+
+    # results_host = simulate(input, meta)
+    input.compile_version = CompileVersion.NETQASM_RETRY
+    results_nqasm = simulate(input, meta)
+
+    input.compile_version = CompileVersion.NO_RETRY
+    input.fidelity = 0.9
+    input.prob_success = 1
+    results_no_retry = simulate(input, meta)
+
+    raw_data = {
+        "nqasm_retry": {f: r.serialize() for f, r in results_nqasm.items()},
+        # "host_retry": {f: r.serialize() for f, r in results_host.items()},
+        "no_retry": {f: r.serialize() for f, r in results_no_retry.items()},
+    }
+
+    dump_data(raw_data, "host_qnos_latency")
+
+    # plot_host_qnos_latency_duration(results_nqasm, results_host, results_no_retry)
+    # plot_host_qnos_latency_error_rate(results_nqasm, results_host, results_no_retry)
+
+    plot_host_qnos_latency_error_rate(results_nqasm, None, results_no_retry)
diff --git a/analysis/fidelity_constraint/config_nv.yaml b/analysis/fidelity_constraint/config_nv.yaml
new file mode 100644
index 00000000..cb3dcf94
--- /dev/null
+++ b/analysis/fidelity_constraint/config_nv.yaml
@@ -0,0 +1,39 @@
+qdevice_cfg: &qdevice_cfg
+  num_qubits: 2
+  # electron_T1: 10.e+6
+  # electron_T2: 10.e+6
+  # carbon_T1: 100.e+6
+  # carbon_T2: 100.e+6
+  init_time: 1.e+1
+  single_qubit_gate_time: 1.e+1
+  two_qubit_gate_time: 1.e+1
+  measurement_time: 1.e+1
+
+stacks:
+  - name: client
+    qdevice_typ: nv
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+    host_qnos_latency: 1e6
+  - name: server
+    qdevice_typ: nv
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+    host_qnos_latency: 1e6
+  
+link_cfg: &link_cfg
+  # fidelity: 0.75
+  # fidelity: 0.99
+  fidelity: 1
+  # prob_success: 5.e-5  # 1 / 20_000
+  # prob_success: 2.e-4  # 1 / 5_000
+  # prob_success: 1
+  prob_success: 0.0005
+  t_cycle: 5.e+3
+
+links:
+  - stack1: client
+    stack2: server
+    typ: depolarise
+    cfg:
+      <<: *link_cfg
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/plot.py b/analysis/fidelity_constraint/plot.py
new file mode 100644
index 00000000..129320d9
--- /dev/null
+++ b/analysis/fidelity_constraint/plot.py
@@ -0,0 +1,86 @@
+import datetime
+import json
+import os
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+
+COMPILE_VERSIONS = ["nqasm_retry", "host_retry"]
+FORMATS = {
+    "nqasm_retry": "-ro",
+    "host_retry": "-bs",
+}
+FORMATS_2 = {
+    "nqasm_retry": "--ro",
+    "host_retry": "--bo",
+}
+VERSION_LABELS = {
+    "nqasm_retry": "NetQASM retry",
+    "host_retry": "Host retry",
+}
+
+X_LABELS = {
+    "fidelity": "Fidelity",
+    "rate": "Success probability per entanglement attempt",
+    "t2": "T2 (ns)",
+    "gate_noise": "2-qubit gate depolarising probability",
+    "gate_noise_trap": "2-qubit gate depolarising probability",
+    "gate_time": "2-qubit gate duration (ms)",
+    "gate_time_trap": "2-qubit gate duration (ms)",
+    "latency": "Host <-> QNodeOS latency (ms)",
+}
+
+
+def create_png(param_name):
+    output_dir = os.path.join(os.path.dirname(__file__), "plots")
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_path = os.path.join(output_dir, f"bqc_sweep_{param_name}_{timestamp}.png")
+    plt.savefig(output_path)
+    print(f"plot written to {output_path}")
+
+
+def plot_host_qnos_latency(data: Dict[float, SimulationOutput]):
+    param_name = "host_qnos_latency"
+
+    data_path = os.path.join(
+        os.path.dirname(__file__), f"sweep_data_bqc/sweep_{param_name}.json"
+    )
+
+    with open(data_path, "r") as f:
+        all_data = json.load(f)
+
+    fig, ax = plt.subplots()
+
+    ax.grid()
+    ax.set_xlabel(X_LABELS[param_name])
+    ax.set_ylabel("Error rate")
+
+    for version in COMPILE_VERSIONS:
+        data = all_data[version]
+        sweep_values = [v["sweep_value"] for v in data]
+        error_rates = [v["error_rate"] for v in data]
+        std_errs = [v["std_err"] for v in data]
+        ax.errorbar(
+            x=sweep_values,
+            y=error_rates,
+            yerr=std_errs,
+            fmt=FORMATS[version],
+            label=VERSION_LABELS[version],
+        )
+
+    ax.set_title(
+        "BQC trap round error rate vs two-qubit gate noise probability",
+        wrap=True,
+    )
+
+    # ax.set_ylim(0.10, 0.35)
+    # ax.axhline(y=0.25, color="red", label="BQC threshold")
+    ax.legend()
+    # plt.tight_layout()
+
+    create_png(param_name)
+
+
+if __name__ == "__main__":
+    plot_gate_noise_trap()
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_115239.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_115239.png
new file mode 100644
index 00000000..dfa276a3
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_115239.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120122.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120122.png
new file mode 100644
index 00000000..6f1b4b32
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120122.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120357.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120357.png
new file mode 100644
index 00000000..d9771c16
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_120357.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_121001.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_121001.png
new file mode 100644
index 00000000..408879c4
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_121001.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_132351.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_132351.png
new file mode 100644
index 00000000..75a7c1e8
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_132351.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_133556.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_133556.png
new file mode 100644
index 00000000..14447cf2
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_20220307_133556.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133659.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133659.png
new file mode 100644
index 00000000..d71b57d8
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133659.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133919.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133919.png
new file mode 100644
index 00000000..4942d7da
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_133919.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_135509.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_135509.png
new file mode 100644
index 00000000..6722168e
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_135509.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_141836.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_141836.png
new file mode 100644
index 00000000..8445fed0
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_141836.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142239.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142239.png
new file mode 100644
index 00000000..5bf31ee5
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142239.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142311.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142311.png
new file mode 100644
index 00000000..434d1c01
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142311.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142741.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142741.png
new file mode 100644
index 00000000..5e0fe2cd
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_duration_20220307_142741.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133659.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133659.png
new file mode 100644
index 00000000..a5bb661e
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133659.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133919.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133919.png
new file mode 100644
index 00000000..065429b2
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_133919.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_135509.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_135509.png
new file mode 100644
index 00000000..c7fad8b5
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_135509.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_141836.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_141836.png
new file mode 100644
index 00000000..34fbccee
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_141836.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142311.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142311.png
new file mode 100644
index 00000000..a8d2f3cc
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142311.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142741.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142741.png
new file mode 100644
index 00000000..9dfce9b7
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_142741.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143104.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143104.png
new file mode 100644
index 00000000..f311fdac
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143104.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143513.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143513.png
new file mode 100644
index 00000000..f2fe5f1c
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_143513.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144159.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144159.png
new file mode 100644
index 00000000..c0399afa
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144159.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144508.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144508.png
new file mode 100644
index 00000000..98c6a721
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144508.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144858.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144858.png
new file mode 100644
index 00000000..a1668c8f
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_144858.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150051.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150051.png
new file mode 100644
index 00000000..218fc9fe
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150051.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150724.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150724.png
new file mode 100644
index 00000000..90b7f1f6
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150724.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150905.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150905.png
new file mode 100644
index 00000000..3a4a58be
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_150905.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_151910.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_151910.png
new file mode 100644
index 00000000..06f29477
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_151910.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_152826.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_152826.png
new file mode 100644
index 00000000..245974d1
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_152826.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_153802.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_153802.png
new file mode 100644
index 00000000..ad0cd1d9
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_153802.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_154030.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_154030.png
new file mode 100644
index 00000000..a32aa0e8
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_154030.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_160652.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_160652.png
new file mode 100644
index 00000000..3e58ed03
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_160652.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_161151.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_161151.png
new file mode 100644
index 00000000..1c760caa
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_161151.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_162118.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_162118.png
new file mode 100644
index 00000000..5144ce24
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220307_162118.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103101.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103101.png
new file mode 100644
index 00000000..72367888
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103101.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103442.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103442.png
new file mode 100644
index 00000000..2447b80d
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_103442.png differ
diff --git a/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_105021.png b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_105021.png
new file mode 100644
index 00000000..fa9f58e6
Binary files /dev/null and b/analysis/fidelity_constraint/plots/bqc_sweep_host_qnos_latency_error_rate_20220308_105021.png differ
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_132351.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_132351.json
new file mode 100644
index 00000000..5c42110d
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_132351.json
@@ -0,0 +1,204 @@
+{
+    "nqasm_retry": {
+        "1000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 28479400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "2000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 34224400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "3000000": {
+            "error_rate": 1.0,
+            "duration": {
+                "mean": 107224400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 2.0,
+                "std_error": 0.0
+            }
+        },
+        "4000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 40204400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "5000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 54094400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "6000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 55014400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "7000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 64864400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "8000000": {
+            "error_rate": 1.0,
+            "duration": {
+                "mean": 77409400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "9000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 73459400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        }
+    },
+    "host_retry": {
+        "1000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 132144400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 5.0,
+                "std_error": 0.0
+            }
+        },
+        "2000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 89354400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 4.0,
+                "std_error": 0.0
+            }
+        },
+        "3000000": {
+            "error_rate": 1.0,
+            "duration": {
+                "mean": 94609400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 3.0,
+                "std_error": 0.0
+            }
+        },
+        "4000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 82724400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 3.0,
+                "std_error": 0.0
+            }
+        },
+        "5000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 36844400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 1.0,
+                "std_error": 0.0
+            }
+        },
+        "6000000": {
+            "error_rate": 1.0,
+            "duration": {
+                "mean": 193999400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 5.0,
+                "std_error": 0.0
+            }
+        },
+        "7000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 210154400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 5.0,
+                "std_error": 0.0
+            }
+        },
+        "8000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 133564400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 3.0,
+                "std_error": 0.0
+            }
+        },
+        "9000000": {
+            "error_rate": 0.0,
+            "duration": {
+                "mean": 198339400.0,
+                "std_error": 0.0
+            },
+            "attempt_coutn": {
+                "mean": 5.0,
+                "std_error": 0.0
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133555.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133555.json
new file mode 100644
index 00000000..03386843
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133555.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 20989400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 28919400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 130279400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 49984400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 1.0, "duration": {"mean": 62069400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 64379400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 68004400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 63664400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 76419400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 100754400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 174909400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 8.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 119849400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 36559400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 81889400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 187354400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 329184400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 9.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 58249400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 1.0, "duration": {"mean": 62199400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133638.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133638.json
new file mode 100644
index 00000000..d15088c1
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133638.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 17829400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 30239400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 1.0, "duration": {"mean": 33969400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 35859400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 53734400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 44344400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 50769400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 62449400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 85859400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 171189400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 61444400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 30694400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 204884400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 208064400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 241539400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 89484400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 373339400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 8.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 64884400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133659.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133659.json
new file mode 100644
index 00000000..aac68a37
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133659.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 38369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 28099400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 39894400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 57109400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 167029400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 53999400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 64739400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 69259400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 77569400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 139324400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 27089400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 216279400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 130194400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 193914400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 6.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 252809400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 116249400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "8000000": {"error_rate": 1.0, "duration": {"mean": 98159400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 67329400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133919.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133919.json
new file mode 100644
index 00000000..5019f5cc
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_133919.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.16, "duration": {"mean": 39625200.0, "std_error": 5754911.673900826}, "attempt_coutn": {"mean": 1.36, "std_error": 0.1483778959279312}}, "2000000": {"error_rate": 0.12, "duration": {"mean": 53429600.0, "std_error": 5417459.932329911}, "attempt_coutn": {"mean": 1.48, "std_error": 0.12800000000000003}}, "3000000": {"error_rate": 0.2, "duration": {"mean": 47996200.0, "std_error": 4802116.3741000695}, "attempt_coutn": {"mean": 1.28, "std_error": 0.1061319932913728}}, "4000000": {"error_rate": 0.12, "duration": {"mean": 46876600.0, "std_error": 2417891.5621673362}, "attempt_coutn": {"mean": 1.12, "std_error": 0.06499230723708768}}, "5000000": {"error_rate": 0.16, "duration": {"mean": 66444000.0, "std_error": 6646353.309417127}, "attempt_coutn": {"mean": 1.32, "std_error": 0.12289833196589772}}, "6000000": {"error_rate": 0.2, "duration": {"mean": 64191600.0, "std_error": 2981201.9465980497}, "attempt_coutn": {"mean": 1.24, "std_error": 0.08541662601625047}}, "7000000": {"error_rate": 0.12, "duration": {"mean": 83242600.0, "std_error": 5583048.614368319}, "attempt_coutn": {"mean": 1.56, "std_error": 0.1505191017778142}}, "8000000": {"error_rate": 0.2, "duration": {"mean": 75013600.0, "std_error": 2903890.8613100457}, "attempt_coutn": {"mean": 1.2, "std_error": 0.08000000000000002}}, "9000000": {"error_rate": 0.16, "duration": {"mean": 83480600.0, "std_error": 3204245.674476288}, "attempt_coutn": {"mean": 1.16, "std_error": 0.07332121111929343}}}, "host_retry": {"1000000": {"error_rate": 0.12, "duration": {"mean": 93727600.0, "std_error": 12550372.918379758}, "attempt_coutn": {"mean": 3.92, "std_error": 0.4696211238860535}}, "2000000": {"error_rate": 0.2, "duration": {"mean": 99167800.0, "std_error": 15195224.01472252}, "attempt_coutn": {"mean": 3.72, "std_error": 0.5292107330733192}}, "3000000": {"error_rate": 0.08, "duration": {"mean": 124151000.0, "std_error": 20113731.08246205}, "attempt_coutn": {"mean": 3.92, "std_error": 0.5984513346964815}}, "4000000": {"error_rate": 0.2, "duration": {"mean": 125098000.0, "std_error": 21184741.812011775}, "attempt_coutn": {"mean": 3.56, "std_error": 0.6198838600899365}}, "5000000": {"error_rate": 0.2, "duration": {"mean": 134437000.0, "std_error": 20431521.16925218}, "attempt_coutn": {"mean": 3.84, "std_error": 0.6515949662175116}}, "6000000": {"error_rate": 0.28, "duration": {"mean": 157691000.0, "std_error": 19887369.812461376}, "attempt_coutn": {"mean": 3.8, "std_error": 0.4931531202375181}}, "7000000": {"error_rate": 0.32, "duration": {"mean": 201669600.0, "std_error": 32222393.786284707}, "attempt_coutn": {"mean": 4.84, "std_error": 0.8441421681209865}}, "8000000": {"error_rate": 0.04, "duration": {"mean": 271210000.0, "std_error": 48787847.42398049}, "attempt_coutn": {"mean": 5.8, "std_error": 1.0998181667894016}}, "9000000": {"error_rate": 0.28, "duration": {"mean": 168885800.0, "std_error": 23626786.841244407}, "attempt_coutn": {"mean": 3.28, "std_error": 0.5107484703843957}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_135508.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_135508.json
new file mode 100644
index 00000000..d67abb21
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_135508.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.13, "duration": {"mean": 35974800.0, "std_error": 2356608.3591466784}, "attempt_coutn": {"mean": 1.24, "std_error": 0.05122499389946282}}, "2000000": {"error_rate": 0.15, "duration": {"mean": 41997500.0, "std_error": 2449299.4945289968}, "attempt_coutn": {"mean": 1.23, "std_error": 0.05631163290120435}}, "3000000": {"error_rate": 0.17, "duration": {"mean": 49804500.0, "std_error": 2785358.69770843}, "attempt_coutn": {"mean": 1.31, "std_error": 0.06587108622149782}}, "4000000": {"error_rate": 0.17, "duration": {"mean": 65962550.0, "std_error": 3358384.4245820018}, "attempt_coutn": {"mean": 1.58, "std_error": 0.07769169839822011}}, "5000000": {"error_rate": 0.13, "duration": {"mean": 59473600.0, "std_error": 2520476.3842575476}, "attempt_coutn": {"mean": 1.23, "std_error": 0.050705029336348906}}, "6000000": {"error_rate": 0.23, "duration": {"mean": 67801650.0, "std_error": 2365420.0455468767}, "attempt_coutn": {"mean": 1.32, "std_error": 0.05979966555090417}}, "7000000": {"error_rate": 0.29, "duration": {"mean": 82681000.0, "std_error": 3886434.2396855243}, "attempt_coutn": {"mean": 1.45, "std_error": 0.08170067319184099}}, "8000000": {"error_rate": 0.33, "duration": {"mean": 75850000.0, "std_error": 1877359.3226657491}, "attempt_coutn": {"mean": 1.21, "std_error": 0.04537620521815373}}, "9000000": {"error_rate": 0.23, "duration": {"mean": 82549900.0, "std_error": 2057706.1445940235}, "attempt_coutn": {"mean": 1.23, "std_error": 0.05070502933634889}}}, "host_retry": {"1000000": {"error_rate": 0.1, "duration": {"mean": 113251763.63636364, "std_error": 12784263.741121525}, "attempt_coutn": {"mean": 4.418181818181818, "std_error": 0.4746052968822624}}, "2000000": {"error_rate": 0.09, "duration": {"mean": 130424350.0, "std_error": 14041945.985776868}, "attempt_coutn": {"mean": 4.55, "std_error": 0.4548351349665062}}, "3000000": {"error_rate": 0.21, "duration": {"mean": 118385450.0, "std_error": 12127285.5652646}, "attempt_coutn": {"mean": 3.91, "std_error": 0.38758095928463787}}, "4000000": {"error_rate": 0.17, "duration": {"mean": 158052650.0, "std_error": 15335427.7537953}, "attempt_coutn": {"mean": 4.56, "std_error": 0.4311194730002346}}, "5000000": {"error_rate": 0.3, "duration": {"mean": 188459100.0, "std_error": 13547996.574183946}, "attempt_coutn": {"mean": 5.17, "std_error": 0.3800144734085796}}, "6000000": {"error_rate": 0.14, "duration": {"mean": 184106750.0, "std_error": 17658167.804652758}, "attempt_coutn": {"mean": 4.66, "std_error": 0.4615668965599678}}, "7000000": {"error_rate": 0.12, "duration": {"mean": 169681900.0, "std_error": 12201509.963217668}, "attempt_coutn": {"mean": 3.95, "std_error": 0.319491783931919}}, "8000000": {"error_rate": 0.19, "duration": {"mean": 192833150.0, "std_error": 13214322.028082829}, "attempt_coutn": {"mean": 4.17, "std_error": 0.31434217025400846}}, "9000000": {"error_rate": 0.23, "duration": {"mean": 172390600.0, "std_error": 13550703.725290427}, "attempt_coutn": {"mean": 3.54, "std_error": 0.319192731746824}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_141835.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_141835.json
new file mode 100644
index 00000000..1f419843
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_141835.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 14459400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 36504400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 45874400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 32074400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 39304400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 56174400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 52594400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 70394400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 199169400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 280989400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 10.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 65114400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 54434400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 194349400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 352374400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 9.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 140684400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "7000000": {"error_rate": 1.0, "duration": {"mean": 165364400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 361409400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 146464400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142238.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142238.json
new file mode 100644
index 00000000..b7e44de3
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142238.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 14804400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 37054400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 45544400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 43184400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 1.0, "duration": {"mean": 42944400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 51144400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 112914400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 69634400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 81284400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 141289400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 77534400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 68859400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 32329400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 180579400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 5.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 48554400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 50594400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 60009400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 64889400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 17949400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 70769400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 46209400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 40444400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 40819400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 54679400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 91899400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 1.0, "duration": {"mean": 71264400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 77389400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142310.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142310.json
new file mode 100644
index 00000000..a787ffe7
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142310.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 23574400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 26214400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 37664400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 42919400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 40479400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 67864400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 1.0, "duration": {"mean": 60289400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 60064400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 145219400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}}, "host_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 51314400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 26719400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 94789400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 4.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 480639400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 16.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 259749400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 8.0, "std_error": 0.0}}, "6000000": {"error_rate": 1.0, "duration": {"mean": 46849400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 136659400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 143269400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 268624400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 36744400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 42739400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 1.0, "duration": {"mean": 37519400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 64174400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 56669400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 46964400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 59034400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 76369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 66949400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142740.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142740.json
new file mode 100644
index 00000000..b3b34e9b
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_142740.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.14, "duration": {"mean": 35251700.0, "std_error": 3153432.4607005618}, "attempt_coutn": {"mean": 1.2, "std_error": 0.06928203230275506}}, "2000000": {"error_rate": 0.06, "duration": {"mean": 38639400.0, "std_error": 3135877.01927228}, "attempt_coutn": {"mean": 1.18, "std_error": 0.06746851117373193}}, "3000000": {"error_rate": 0.22, "duration": {"mean": 51282800.0, "std_error": 3392241.885361361}, "attempt_coutn": {"mean": 1.3, "std_error": 0.07071067811865474}}, "4000000": {"error_rate": 0.14, "duration": {"mean": 54881100.0, "std_error": 3065059.5968431025}, "attempt_coutn": {"mean": 1.28, "std_error": 0.06951258878793107}}, "5000000": {"error_rate": 0.2, "duration": {"mean": 59458600.0, "std_error": 3792079.20898285}, "attempt_coutn": {"mean": 1.24, "std_error": 0.07776888838089435}}, "6000000": {"error_rate": 0.18, "duration": {"mean": 73935900.0, "std_error": 4376108.884042992}, "attempt_coutn": {"mean": 1.46, "std_error": 0.10662082348209474}}, "7000000": {"error_rate": 0.18, "duration": {"mean": 73034700.0, "std_error": 4482783.9684954705}, "attempt_coutn": {"mean": 1.24, "std_error": 0.09616652224137047}}, "8000000": {"error_rate": 0.24, "duration": {"mean": 78091500.0, "std_error": 3644584.849032877}, "attempt_coutn": {"mean": 1.28, "std_error": 0.08962142600963224}}, "9000000": {"error_rate": 0.24, "duration": {"mean": 90389300.0, "std_error": 4353464.292928104}, "attempt_coutn": {"mean": 1.38, "std_error": 0.08433267456923203}}}, "host_retry": {"1000000": {"error_rate": 0.08, "duration": {"mean": 95870400.0, "std_error": 10708470.42672295}, "attempt_coutn": {"mean": 3.8, "std_error": 0.3644173431657719}}, "2000000": {"error_rate": 0.22, "duration": {"mean": 113927300.0, "std_error": 17203357.567108806}, "attempt_coutn": {"mean": 4.0, "std_error": 0.5491812087098392}}, "3000000": {"error_rate": 0.2, "duration": {"mean": 138501100.0, "std_error": 20292409.61522805}, "attempt_coutn": {"mean": 4.22, "std_error": 0.5832940939183252}}, "4000000": {"error_rate": 0.14, "duration": {"mean": 146847000.0, "std_error": 17172451.17753432}, "attempt_coutn": {"mean": 4.22, "std_error": 0.4777363289514417}}, "5000000": {"error_rate": 0.2, "duration": {"mean": 167630800.0, "std_error": 17969407.174439557}, "attempt_coutn": {"mean": 4.52, "std_error": 0.49658030569083184}}, "6000000": {"error_rate": 0.2, "duration": {"mean": 177418200.0, "std_error": 19090415.9344735}, "attempt_coutn": {"mean": 4.44, "std_error": 0.5037142046835685}}, "7000000": {"error_rate": 0.2, "duration": {"mean": 196556500.0, "std_error": 20599745.341188073}, "attempt_coutn": {"mean": 4.68, "std_error": 0.5203383514598938}}, "8000000": {"error_rate": 0.3, "duration": {"mean": 221713300.0, "std_error": 23789866.467170432}, "attempt_coutn": {"mean": 4.82, "std_error": 0.546032966037766}}, "9000000": {"error_rate": 0.18, "duration": {"mean": 256986600.0, "std_error": 28855360.52284219}, "attempt_coutn": {"mean": 5.42, "std_error": 0.6717678170320454}}}, "no_retry": {"1000000": {"error_rate": 0.1, "duration": {"mean": 31671300.0, "std_error": 1660226.9537024146}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.1, "duration": {"mean": 37045300.0, "std_error": 1524626.798203416}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.18, "duration": {"mean": 43422400.0, "std_error": 1894926.167427111}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.12, "duration": {"mean": 50527600.0, "std_error": 2363757.478084416}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.26, "duration": {"mean": 55794700.0, "std_error": 1816526.0273940475}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.14, "duration": {"mean": 65650700.0, "std_error": 2276438.8716150494}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.22, "duration": {"mean": 65090200.0, "std_error": 1573706.6966877913}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.16, "duration": {"mean": 74845000.0, "std_error": 2060311.1106820735}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.22, "duration": {"mean": 80490300.0, "std_error": 2008876.117086367}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143103.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143103.json
new file mode 100644
index 00000000..5fc9e5d1
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143103.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 36784400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 33279400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 1.0, "duration": {"mean": 42784400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 122169400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 3.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 50324400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 50474400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 65039400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 71264400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 65204400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 37714400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 25574400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 55279400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 31199400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 68154400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 43649400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 1.0, "duration": {"mean": 64034400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 62659400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 67494400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143513.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143513.json
new file mode 100644
index 00000000..4f87af15
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_143513.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 36849400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 26789400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 31464400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 47964400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 46949400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 52889400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 62269400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 66609400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 72299400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 16939400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 46644400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 58439400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 121389400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 46489400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 1.0, "duration": {"mean": 48134400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 61464400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 72794400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 1.0, "duration": {"mean": 107779400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144159.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144159.json
new file mode 100644
index 00000000..839eccb3
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144159.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 5728079400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 34.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 500269400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 2.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 43434400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 5268494400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 22.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 3120824400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 13.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 3710079400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 14.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 8315629400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 41.0, "std_error": 0.0}}, "8000000": {"error_rate": 1.0, "duration": {"mean": 58289400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 18848694400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 101.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 197294400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 243809400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 119369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 1.0, "duration": {"mean": 428269400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.0, "duration": {"mean": 153699400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 265049400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 140349400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 1.0, "duration": {"mean": 239874400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 1.0, "duration": {"mean": 272104400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144508.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144508.json
new file mode 100644
index 00000000..e1c2dad5
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144508.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.0, "duration": {"mean": 6364639400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 31.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.0, "duration": {"mean": 2240059400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 13.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 6398904400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 31.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 8940419400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 52.0, "std_error": 0.0}}, "5000000": {"error_rate": 1.0, "duration": {"mean": 4368439400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 24.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 4510599400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 23.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 1596334400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 10.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 400304400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 5.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 743009400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 5.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"error_rate": 1.0, "duration": {"mean": 438869400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 1.0, "duration": {"mean": 224519400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.0, "duration": {"mean": 149644400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.0, "duration": {"mean": 133049400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 1.0, "duration": {"mean": 109574400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.0, "duration": {"mean": 165039400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.0, "duration": {"mean": 111234400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.0, "duration": {"mean": 181439400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.0, "duration": {"mean": 101219400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144858.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144858.json
new file mode 100644
index 00000000..7997852e
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_144858.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"error_rate": 0.3, "duration": {"mean": 5470138400.0, "std_error": 1377174169.430069}, "attempt_coutn": {"mean": 29.6, "std_error": 7.106616635221011}}, "2000000": {"error_rate": 0.1, "duration": {"mean": 4409389900.0, "std_error": 902315086.7334119}, "attempt_coutn": {"mean": 23.2, "std_error": 5.065175219081763}}, "3000000": {"error_rate": 0.3, "duration": {"mean": 6555908400.0, "std_error": 2776931900.1487775}, "attempt_coutn": {"mean": 35.4, "std_error": 15.30829840315376}}, "4000000": {"error_rate": 0.2, "duration": {"mean": 5575417400.0, "std_error": 1274470679.344213}, "attempt_coutn": {"mean": 26.3, "std_error": 5.331134963588898}}, "5000000": {"error_rate": 0.2, "duration": {"mean": 4778704900.0, "std_error": 1546948399.4247272}, "attempt_coutn": {"mean": 23.4, "std_error": 7.605524308027684}}, "6000000": {"error_rate": 0.1, "duration": {"mean": 4587632400.0, "std_error": 1226617282.848077}, "attempt_coutn": {"mean": 22.9, "std_error": 6.203950354411292}}, "7000000": {"error_rate": 0.2, "duration": {"mean": 8516200400.0, "std_error": 2969101623.010721}, "attempt_coutn": {"mean": 43.2, "std_error": 14.793782477784376}}, "8000000": {"error_rate": 0.3, "duration": {"mean": 3304223400.0, "std_error": 669727006.0449257}, "attempt_coutn": {"mean": 16.9, "std_error": 3.564968443058087}}, "9000000": {"error_rate": 0.1, "duration": {"mean": 9875509400.0, "std_error": 1591087299.3404543}, "attempt_coutn": {"mean": 52.1, "std_error": 8.258874015263824}}}, "no_retry": {"1000000": {"error_rate": 0.1, "duration": {"mean": 282424900.0, "std_error": 54213876.63896578}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"error_rate": 0.1, "duration": {"mean": 217757900.0, "std_error": 56429253.12304779}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"error_rate": 0.1, "duration": {"mean": 312773900.0, "std_error": 42260099.132929154}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"error_rate": 0.3, "duration": {"mean": 257576400.0, "std_error": 33692348.22033038}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"error_rate": 0.4, "duration": {"mean": 312358900.0, "std_error": 45695288.41385071}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"error_rate": 0.4, "duration": {"mean": 349934400.0, "std_error": 62397260.97754612}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"error_rate": 0.4, "duration": {"mean": 239144400.0, "std_error": 42477830.629635505}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"error_rate": 0.4, "duration": {"mean": 259417400.0, "std_error": 43091097.724472046}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"error_rate": 0.2, "duration": {"mean": 232122400.0, "std_error": 25419932.93854254}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150051.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150051.json
new file mode 100644
index 00000000..1dd464e6
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150051.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 3421204400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 19.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 8891324400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 41.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 21166534400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 104.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 1825909400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 12.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 5745959400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 37.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 6588554400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 29.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 12561624400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 71.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 2267274400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 13.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.0, "conf_95": 0.0}, "duration": {"mean": 778679400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 7.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 390614400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 66009400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 231489400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 393844400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.0, "conf_95": 0.0}, "duration": {"mean": 401914400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 162124400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.0, "conf_95": 0.0}, "duration": {"mean": 123639400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.0, "conf_95": 0.0}, "duration": {"mean": 102094400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 124144400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150724.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150724.json
new file mode 100644
index 00000000..8c8c82e7
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150724.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.13148079707698762}, "duration": {"mean": 4935330400.0, "std_error": 1091837684.6207843}, "attempt_coutn": {"mean": 25.0, "std_error": 5.384236250388721}}, "2000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.20084023501280815}, "duration": {"mean": 7723514900.0, "std_error": 1781675486.581342}, "attempt_coutn": {"mean": 37.45, "std_error": 8.25393088170721}}, "3000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.1753077294359835}, "duration": {"mean": 6085366400.0, "std_error": 1527527476.0900946}, "attempt_coutn": {"mean": 28.9, "std_error": 7.085866213809007}}, "4000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.1753077294359835}, "duration": {"mean": 6682915650.0, "std_error": 1189572429.8561475}, "attempt_coutn": {"mean": 34.25, "std_error": 6.021160602408807}}, "5000000": {"succ_rate": {"success_rate": 0.85, "conf_95": 0.15649345034217885}, "duration": {"mean": 5896770150.0, "std_error": 1599404079.4797318}, "attempt_coutn": {"mean": 30.3, "std_error": 8.090766341948086}}, "6000000": {"succ_rate": {"success_rate": 0.85, "conf_95": 0.15649345034217885}, "duration": {"mean": 7832765150.0, "std_error": 1561548981.7636714}, "attempt_coutn": {"mean": 36.55, "std_error": 6.915010845978479}}, "7000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.1753077294359835}, "duration": {"mean": 7258641150.0, "std_error": 1777274149.1447046}, "attempt_coutn": {"mean": 36.95, "std_error": 8.871154096283075}}, "8000000": {"succ_rate": {"success_rate": 0.85, "conf_95": 0.15649345034217885}, "duration": {"mean": 6690842150.0, "std_error": 1360232860.879318}, "attempt_coutn": {"mean": 32.6, "std_error": 6.357436590324752}}, "9000000": {"succ_rate": {"success_rate": 0.75, "conf_95": 0.18977618396416343}, "duration": {"mean": 6918455650.0, "std_error": 1300394383.657602}, "attempt_coutn": {"mean": 35.8, "std_error": 6.585818096485813}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.20084023501280815}, "duration": {"mean": 229306650.0, "std_error": 25739254.87090438}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.65, "conf_95": 0.2090411442754751}, "duration": {"mean": 216073650.0, "std_error": 32666120.662842333}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.1753077294359835}, "duration": {"mean": 305084650.0, "std_error": 45983204.185706496}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.20084023501280815}, "duration": {"mean": 267684650.0, "std_error": 31480797.509106636}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.1753077294359835}, "duration": {"mean": 252854900.0, "std_error": 33113897.573186688}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.65, "conf_95": 0.2090411442754751}, "duration": {"mean": 284306400.0, "std_error": 29912572.892514613}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.95, "conf_95": 0.09551858457912789}, "duration": {"mean": 238246900.0, "std_error": 23849655.808575094}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.75, "conf_95": 0.18977618396416343}, "duration": {"mean": 273959650.0, "std_error": 41252907.46492149}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.4, "conf_95": 0.2147072425420251}, "duration": {"mean": 295304400.0, "std_error": 37687441.48751677}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150905.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150905.json
new file mode 100644
index 00000000..6ad6db85
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_150905.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 5542304400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 31.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 14053549400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 68.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 1339514400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 5.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 164979400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 166639400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 163684400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_151909.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_151909.json
new file mode 100644
index 00000000..c240a4ff
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_151909.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.84, "conf_95": 0.07185478689690758}, "duration": {"mean": 6137740300.0, "std_error": 549073337.9157805}, "attempt_coutn": {"mean": 30.2, "std_error": 2.5371637708275747}}, "5000000": {"succ_rate": {"success_rate": 0.68, "conf_95": 0.0914293257111743}, "duration": {"mean": 5794091750.0, "std_error": 628077016.2861297}, "attempt_coutn": {"mean": 28.37, "std_error": 2.961643293848873}}, "9000000": {"succ_rate": {"success_rate": 0.79, "conf_95": 0.0798324144693119}, "duration": {"mean": 7191248850.0, "std_error": 752379154.9129133}, "attempt_coutn": {"mean": 35.33, "std_error": 3.5653626743993376}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.76, "conf_95": 0.08370829349592548}, "duration": {"mean": 221526600.0, "std_error": 16181930.06308579}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.65, "conf_95": 0.09348604173886066}, "duration": {"mean": 261027100.0, "std_error": 17187430.297083393}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.69, "conf_95": 0.09064867566600188}, "duration": {"mean": 255649500.0, "std_error": 12589764.860985292}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_152826.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_152826.json
new file mode 100644
index 00000000..07a722ff
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_152826.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.12702251768879408}, "duration": {"mean": 7131609000.0, "std_error": 1020580165.058246}, "attempt_coutn": {"mean": 34.68, "std_error": 4.92905183579966}}, "5000000": {"succ_rate": {"success_rate": 0.46, "conf_95": 0.1381487198637758}, "duration": {"mean": 6036479700.0, "std_error": 808833693.2587245}, "attempt_coutn": {"mean": 29.84, "std_error": 3.735383246736537}}, "9000000": {"succ_rate": {"success_rate": 0.52, "conf_95": 0.13848201038402064}, "duration": {"mean": 6103913400.0, "std_error": 756834725.8413029}, "attempt_coutn": {"mean": 31.02, "std_error": 3.782643520079575}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.5, "conf_95": 0.13859292911256332}, "duration": {"mean": 201206000.0, "std_error": 18385899.24068985}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.5, "conf_95": 0.13859292911256332}, "duration": {"mean": 218029600.0, "std_error": 17540710.05059943}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.46, "conf_95": 0.1381487198637758}, "duration": {"mean": 235345900.0, "std_error": 15484550.777629932}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_153801.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_153801.json
new file mode 100644
index 00000000..b449495a
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_153801.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 9827014400.0, "std_error": 2428455732.162108}, "attempt_coutn": {"mean": 49.6, "std_error": 12.013492414780973}}, "5000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 5844035900.0, "std_error": 1771138158.4436107}, "attempt_coutn": {"mean": 29.2, "std_error": 8.434216027586677}}, "9000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 7156403900.0, "std_error": 1648834748.6416657}, "attempt_coutn": {"mean": 34.0, "std_error": 8.668333173107733}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 12369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.2, "conf_95": 0.24792256855720096}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_154030.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_154030.json
new file mode 100644
index 00000000..6ece1bf2
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_154030.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 13002692900.0, "std_error": 3852064662.384644}, "attempt_coutn": {"mean": 66.0, "std_error": 18.275119698650403}}, "5000000": {"succ_rate": {"success_rate": 0.4, "conf_95": 0.3036418943426615}, "duration": {"mean": 11556381400.0, "std_error": 1663223912.6613708}, "attempt_coutn": {"mean": 55.8, "std_error": 8.284684665091364}}, "9000000": {"succ_rate": {"success_rate": 0.3, "conf_95": 0.284030984225313}, "duration": {"mean": 12176644400.0, "std_error": 3137637323.437573}, "attempt_coutn": {"mean": 58.6, "std_error": 14.289996501049256}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 12069400.0, "std_error": 77459.66692414833}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.5, "conf_95": 0.3099032106965012}, "duration": {"mean": 60269400.0, "std_error": 63245.553203367585}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_160651.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_160651.json
new file mode 100644
index 00000000..4a84f334
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_160651.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 18068883400.0, "std_error": 4693998831.085591}, "attempt_coutn": {"mean": 90.5, "std_error": 23.837470503390247}}, "5000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 7904274900.0, "std_error": 2061180213.5333107}, "attempt_coutn": {"mean": 36.5, "std_error": 9.217646120349816}}, "9000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 12543341900.0, "std_error": 2874998819.4484754}, "attempt_coutn": {"mean": 63.1, "std_error": 13.888448437460534}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 12369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.5, "conf_95": 0.3099032106965012}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_161150.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_161150.json
new file mode 100644
index 00000000..ee29f599
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_161150.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 13578089400.0, "std_error": 5057611420.556101}, "attempt_coutn": {"mean": 66.3, "std_error": 24.79679414763126}}, "5000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 9794485400.0, "std_error": 2396385923.0546317}, "attempt_coutn": {"mean": 47.3, "std_error": 11.200937460766397}}, "9000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 18268593400.0, "std_error": 5954084432.299258}, "attempt_coutn": {"mean": 90.8, "std_error": 29.346822655953744}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 12369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_162118.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_162118.json
new file mode 100644
index 00000000..e72b5cc5
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220307_162118.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.868, "conf_95": 0.029670023983812348}, "duration": {"mean": 12370540.0, "std_error": 119.16710955628655}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.856, "conf_95": 0.030774371883110795}, "duration": {"mean": 36342580.0, "std_error": 5149.288805262335}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.854, "conf_95": 0.030951124515920254}, "duration": {"mean": 60370370.0, "std_error": 108.71154492509064}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.866, "conf_95": 0.02985949197156576}, "duration": {"mean": 12369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.852, "conf_95": 0.03112588612714504}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.776, "conf_95": 0.03654482941265426}, "duration": {"mean": 60366720.0, "std_error": 111.51322791489805}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103101.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103101.json
new file mode 100644
index 00000000..de96831a
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103101.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 12370400.0, "std_error": 632.4555320336758}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 18320400.0, "std_error": 47014.89125798335}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 24369900.0, "std_error": 474.34164902525686}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 30370400.0, "std_error": 632.4555320336758}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 36169400.0, "std_error": 77459.66692414833}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 42371400.0, "std_error": 774.5966692414833}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 48371900.0, "std_error": 790.5694150420948}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 54371400.0, "std_error": 1048.8088481701516}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 12119400.0, "std_error": 79056.94150420948}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 18369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 1.0, "conf_95": 0.0}, "duration": {"mean": 24369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.2479225685572009}, "duration": {"mean": 30369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 36367900.0, "std_error": 724.5688373094719}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.7, "conf_95": 0.284030984225313}, "duration": {"mean": 42369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 48314400.0, "std_error": 47434.164902525685}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.1859419264179007}, "duration": {"mean": 54119400.0, "std_error": 79056.94150420948}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.6, "conf_95": 0.3036418943426615}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103442.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103442.json
new file mode 100644
index 00000000..d9fd631b
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_103442.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.0784}, "duration": {"mean": 12370000.0, "std_error": 177.2004514666935}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.82, "conf_95": 0.07530074103221031}, "duration": {"mean": 18370250.0, "std_error": 212.77922830953213}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.93, "conf_95": 0.05000881522291843}, "duration": {"mean": 24365850.0, "std_error": 4998.647317024877}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.82, "conf_95": 0.07530074103221031}, "duration": {"mean": 30090650.0, "std_error": 24800.34021944054}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.77, "conf_95": 0.08248317161700318}, "duration": {"mean": 36370900.0, "std_error": 312.2498999199199}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.75, "conf_95": 0.08487048957087498}, "duration": {"mean": 42370750.0, "std_error": 298.78922336657325}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.82, "conf_95": 0.07530074103221031}, "duration": {"mean": 48370800.0, "std_error": 308.86890422961}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.72, "conf_95": 0.08800378173692311}, "duration": {"mean": 53870300.0, "std_error": 216.56407827707716}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.84, "conf_95": 0.07185478689690758}, "duration": {"mean": 60370650.0, "std_error": 268.0951323690902}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.88, "conf_95": 0.06369246109234593}, "duration": {"mean": 12334400.0, "std_error": 12757.350822173074}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.9, "conf_95": 0.0588}, "duration": {"mean": 18369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.0784}, "duration": {"mean": 24369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.69, "conf_95": 0.09064867566600188}, "duration": {"mean": 30367050.0, "std_error": 249.54959426935562}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.84, "conf_95": 0.07185478689690758}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.83, "conf_95": 0.07362402868629236}, "duration": {"mean": 42369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.89, "conf_95": 0.06132639236087509}, "duration": {"mean": 48369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.75, "conf_95": 0.08487048957087498}, "duration": {"mean": 54369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.88, "conf_95": 0.06369246109234593}, "duration": {"mean": 60369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_105020.json b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_105020.json
new file mode 100644
index 00000000..94d3d98a
--- /dev/null
+++ b/analysis/fidelity_constraint/sweep_data_bqc/host_qnos_latency_20220308_105020.json
@@ -0,0 +1 @@
+{"nqasm_retry": {"1000000": {"succ_rate": {"success_rate": 0.866, "conf_95": 0.02985949197156576}, "duration": {"mean": 12370630.0, "std_error": 109.88266469284406}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.822, "conf_95": 0.033528720393119694}, "duration": {"mean": 18370530.0, "std_error": 112.00982099798213}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.87, "conf_95": 0.029478295744496494}, "duration": {"mean": 24116570.0, "std_error": 11178.975006681068}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.8, "conf_95": 0.0350615458871967}, "duration": {"mean": 30370440.0, "std_error": 102.16065778958159}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.804, "conf_95": 0.034795824301200276}, "duration": {"mean": 36370540.0, "std_error": 122.4777530819373}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.81, "conf_95": 0.03438669044848602}, "duration": {"mean": 42367960.0, "std_error": 162.64316770156682}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.812, "conf_95": 0.03424743171684557}, "duration": {"mean": 48370580.0, "std_error": 109.61386773579335}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.838, "conf_95": 0.0322961375275744}, "duration": {"mean": 54370470.0, "std_error": 110.49977375542448}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.812, "conf_95": 0.03424743171684557}, "duration": {"mean": 60370570.0, "std_error": 112.96990749752784}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}, "no_retry": {"1000000": {"succ_rate": {"success_rate": 0.854, "conf_95": 0.030951124515920254}, "duration": {"mean": 12369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "2000000": {"succ_rate": {"success_rate": 0.86, "conf_95": 0.03041475431431265}, "duration": {"mean": 18369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "3000000": {"succ_rate": {"success_rate": 0.86, "conf_95": 0.03041475431431265}, "duration": {"mean": 24366980.0, "std_error": 111.74614087296258}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "4000000": {"succ_rate": {"success_rate": 0.82, "conf_95": 0.033675515140825986}, "duration": {"mean": 30369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "5000000": {"succ_rate": {"success_rate": 0.822, "conf_95": 0.033528720393119694}, "duration": {"mean": 36369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "6000000": {"succ_rate": {"success_rate": 0.792, "conf_95": 0.03557667262687729}, "duration": {"mean": 42369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "7000000": {"succ_rate": {"success_rate": 0.822, "conf_95": 0.033528720393119694}, "duration": {"mean": 48327400.0, "std_error": 6202.580108309767}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "8000000": {"succ_rate": {"success_rate": 0.838, "conf_95": 0.0322961375275744}, "duration": {"mean": 54369400.0, "std_error": 0.0}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}, "9000000": {"succ_rate": {"success_rate": 0.798, "conf_95": 0.03519234444023302}, "duration": {"mean": 60326400.0, "std_error": 6269.130721240385}, "attempt_coutn": {"mean": 1.0, "std_error": 0.0}}}}
\ No newline at end of file
diff --git a/examples/stack/classical/config.yaml b/examples/stack/classical/config.yaml
new file mode 100644
index 00000000..f98ad3b6
--- /dev/null
+++ b/examples/stack/classical/config.yaml
@@ -0,0 +1,31 @@
+qdevice_cfg: &qdevice_cfg
+  num_qubits: 2
+  num_comm_qubits: 2
+  T1: 1.e+8
+  T2: 1.e+8
+  init_time: 1.e+4
+  single_qubit_gate_time: 1.e+3
+  two_qubit_gate_time: 1.e+5
+  measurement_time: 1.e+4
+
+stacks:
+  - name: client
+    qdevice_typ: generic
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+  - name: server
+    qdevice_typ: generic
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+  
+link_cfg: &link_cfg
+  fidelity: 0.8
+  prob_success: 0.01
+  t_cycle: 1e3
+
+links:
+  - stack1: client
+    stack2: server
+    typ: depolarise
+    cfg:
+      <<: *link_cfg
\ No newline at end of file
diff --git a/examples/stack/classical/example_classical.py b/examples/stack/classical/example_classical.py
new file mode 100644
index 00000000..2c7d0698
--- /dev/null
+++ b/examples/stack/classical/example_classical.py
@@ -0,0 +1,70 @@
+import os
+from typing import Any, Dict, Generator
+
+from pydynaa import EventExpression
+from squidasm.run.stack.config import StackNetworkConfig
+from squidasm.run.stack.run import run
+from squidasm.sim.stack.common import LogManager
+from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
+
+
+class ClientProgram(Program):
+    PEER = "server"
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="client_program",
+            parameters={},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=1,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        csocket = context.csockets[self.PEER]
+        csocket.send("hello")
+        response = yield from csocket.recv()
+        print(f"received response: {response}")
+        yield from context.connection.flush()
+
+
+class ServerProgram(Program):
+    PEER = "client"
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="server_program",
+            parameters={},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=1,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        csocket = context.csockets[self.PEER]
+        msg = yield from csocket.recv()
+        print(f"received message: {msg}")
+        csocket.send("hello back")
+        yield from context.connection.flush()
+
+
+if __name__ == "__main__":
+    LogManager.set_log_level("WARNING")
+
+    num_times = 1
+    cfg = StackNetworkConfig.from_file(
+        os.path.join(os.getcwd(), os.path.dirname(__file__), "config.yaml")
+    )
+
+    client_program = ClientProgram()
+    server_program = ServerProgram()
+
+    client_results, server_results = run(
+        cfg, {"client": client_program, "server": server_program}, num_times
+    )
diff --git a/examples/stack/coin_flipping/example_coin_flipping.py b/examples/stack/coin_flipping/example_coin_flipping.py
new file mode 100644
index 00000000..8abae4dd
--- /dev/null
+++ b/examples/stack/coin_flipping/example_coin_flipping.py
@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import math
+import os
+from random import randint
+from typing import Any, Dict, Generator
+
+from netqasm.lang.ir import BreakpointAction, BreakpointRole
+from netqasm.sdk.connection import BaseNetQASMConnection
+from netqasm.sdk.qubit import Qubit
+from netqasm.sdk.toolbox import set_qubit_state
+
+from pydynaa import EventExpression
+from squidasm.run.stack.config import (
+    GenericQDeviceConfig,
+    LinkConfig,
+    StackConfig,
+    StackNetworkConfig,
+)
+from squidasm.run.stack.run import run
+from squidasm.sim.stack.common import LogManager
+from squidasm.sim.stack.csocket import ClassicalSocket
+from squidasm.sim.stack.globals import GlobalSimData
+from squidasm.sim.stack.netstack import EprSocket
+from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
+
+M = 1
+N = 1
+
+NUM_QUBITS = 20
+
+
+class CoinFlipProgram(Program):
+    def send_qubit(
+        self, q: Qubit, context: ProgramContext
+    ) -> Generator[EventExpression, None, None]:
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+        epr = epr_socket.create_keep(1)[0]
+        q.cnot(epr)
+        q.H()
+        m1 = q.measure()
+        m2 = epr.measure()
+        yield from context.connection.flush()
+        csocket.send_int(int(m1))
+        csocket.send_int(int(m2))
+
+    def recv_qubit(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Qubit]:
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+        epr = epr_socket.recv_keep(1)[0]
+        yield from context.connection.flush()
+        m1 = yield from csocket.recv_int()
+        m2 = yield from csocket.recv_int()
+        if m2 == 1:
+            epr.X()
+        if m1 == 1:
+            epr.Z()
+        return epr
+
+
+class SenderProgram(CoinFlipProgram):
+    PEER = "receiver"
+
+    def __init__(
+        self,
+        theta: float,
+        phi: float,
+    ):
+        self._theta = theta
+        self._phi = phi
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="sender_program",
+            parameters={
+                "theta": self._theta,
+                "phi": self._phi,
+            },
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=NUM_QUBITS,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        conn = context.connection
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+
+        a = [randint(0, 1) for _ in range(M)]
+        c = [[randint(0, 1) for _ in range(M)] for _ in range(N)]
+
+        rcvd_qubits = [[[None, None] for _ in range(M)] for _ in range(N)]
+        returned_indices = [[None for _ in range(M)] for _ in range(N)]
+        returned_qubits = [[None for _ in range(M)] for _ in range(N)]
+
+        for i in range(N):
+            for j in range(M):
+                sent_q1 = Qubit(conn)
+                sent_q2 = Qubit(conn)
+                if c[i][j] == 1:
+                    sent_q1.X()
+                else:
+                    sent_q2.X()
+                yield from self.send_qubit(sent_q1, context)
+                yield from self.send_qubit(sent_q2, context)
+
+                rcvd_qubits[i][j][0] = yield from self.recv_qubit(context)
+                rcvd_qubits[i][j][1] = yield from self.recv_qubit(context)
+
+        for i in range(N):
+            for j in range(M):
+                e = a[j] ^ c[i][j]
+                csocket.send_int(e)
+
+                returned_qubits[i][j] = yield from self.recv_qubit(context)
+
+                f = yield from csocket.recv_int()
+                if f == 0:
+                    # return 2nd particle
+                    yield from self.send_qubit(rcvd_qubits[i][j][1], context)
+                    returned_indices[i][j] = 1
+                else:
+                    # return 1st particle
+                    yield from self.send_qubit(rcvd_qubits[i][j][0], context)
+                    returned_indices[i][j] = 0
+
+        for j in range(M):
+            csocket.send_int(a[j])
+            b = yield from csocket.recv_int()
+            b_tilde = None
+            for i in range(N):
+                returned_index = returned_indices[i][j]
+                q = rcvd_qubits[i][j][1 - returned_index]
+                b_tilde = q.measure()
+            yield from conn.flush()
+
+        for j in range(M):
+            a = None
+            for i in range(N):
+                returned_index = returned_indices[i][j]
+                q = returned_qubits[i][j]
+                a = q.measure()
+            yield from conn.flush()
+
+        yield from conn.flush()
+
+        final_bit = int(a) ^ int(b_tilde)
+        return {"final_bit": final_bit}
+
+
+class ReceiverProgram(CoinFlipProgram):
+    PEER = "sender"
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="receiver_program",
+            parameters={},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=NUM_QUBITS,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        conn = context.connection
+        epr_socket = context.epr_sockets[self.PEER]
+        csocket: ClassicalSocket = context.csockets[self.PEER]
+
+        b = [randint(0, 1) for _ in range(N)]
+        d = [[randint(0, 1) for _ in range(M)] for _ in range(N)]
+
+        rcvd_qubits = [[[None, None] for _ in range(M)] for _ in range(N)]
+        returned_indices = [[None for _ in range(M)] for _ in range(N)]
+        returned_qubits = [[None for _ in range(M)] for _ in range(N)]
+
+        for i in range(N):
+            for j in range(M):
+                rcvd_qubits[i][j][0] = yield from self.recv_qubit(context)
+                rcvd_qubits[i][j][1] = yield from self.recv_qubit(context)
+
+                sent_q1 = Qubit(conn)
+                sent_q2 = Qubit(conn)
+                if d[i][j] == 1:
+                    sent_q1.X()
+                else:
+                    sent_q2.X()
+                yield from self.send_qubit(sent_q1, context)
+                yield from self.send_qubit(sent_q2, context)
+
+        for i in range(N):
+            for j in range(M):
+                e = yield from csocket.recv_int()
+                if e == 0:
+                    # return 2nd particle
+                    yield from self.send_qubit(rcvd_qubits[i][j][1], context)
+                    returned_indices[i][j] = 1
+                else:
+                    # return 1st particle
+                    yield from self.send_qubit(rcvd_qubits[i][j][0], context)
+                    returned_indices[i][j] = 0
+                f = b[j] ^ d[i][j]
+                csocket.send_int(f)
+
+                returned_qubits[i][j] = yield from self.recv_qubit(context)
+
+        for j in range(M):
+            a = yield from csocket.recv_int()
+            csocket.send_int(b[j])
+            a_tilde = None
+            for i in range(N):
+                returned_index = returned_indices[i][j]
+                q = rcvd_qubits[i][j][1 - returned_index]
+                a_tilde = q.measure()
+            yield from conn.flush()
+
+        for j in range(M):
+            b = None
+            for i in range(N):
+                returned_index = returned_indices[i][j]
+                q = returned_qubits[i][j]
+                b = q.measure()
+            yield from conn.flush()
+
+        yield from conn.flush()
+
+        final_bit = int(a_tilde) ^ int(b)
+        return {"final_bit": final_bit}
+
+
+if __name__ == "__main__":
+    # LogManager.set_log_level("DEBUG")
+    dump_file = os.path.join(os.path.dirname(__file__), "dump_coin_flipping.log")
+    LogManager.log_to_file(dump_file)
+
+    GlobalSimData.create_custom_event_type("EPR attempt")
+
+    sender_stack = StackConfig(
+        name="sender",
+        qdevice_typ="generic",
+        qdevice_cfg=GenericQDeviceConfig.perfect_config(),
+    )
+    sender_stack.qdevice_cfg.num_qubits = NUM_QUBITS
+    sender_stack.qdevice_cfg.num_comm_qubits = NUM_QUBITS
+    receiver_stack = StackConfig(
+        name="receiver",
+        qdevice_typ="generic",
+        qdevice_cfg=GenericQDeviceConfig.perfect_config(),
+    )
+    receiver_stack.qdevice_cfg.num_qubits = NUM_QUBITS
+    receiver_stack.qdevice_cfg.num_comm_qubits = NUM_QUBITS
+    link = LinkConfig(
+        stack1="sender",
+        stack2="receiver",
+        typ="perfect",
+    )
+
+    cfg = StackNetworkConfig(stacks=[sender_stack, receiver_stack], links=[link])
+
+    sender_program = SenderProgram(theta=math.pi, phi=0)
+    receiver_program = ReceiverProgram()
+
+    num_times = 20
+    client_results, server_results = run(
+        cfg,
+        {"sender": sender_program, "receiver": receiver_program},
+        num_times=num_times,
+    )
+
+    for cr, sr in zip(client_results, server_results):
+        cbit = cr["final_bit"]
+        sbit = sr["final_bit"]
+        print(f"bits: {cbit}{sbit}")
diff --git a/examples/stack/fidelity_constraint/config_nv.yaml b/examples/stack/fidelity_constraint/config_nv.yaml
index a7d7e5f8..b5ded0f1 100644
--- a/examples/stack/fidelity_constraint/config_nv.yaml
+++ b/examples/stack/fidelity_constraint/config_nv.yaml
@@ -1,8 +1,9 @@
 qdevice_cfg: &qdevice_cfg
   num_qubits: 2
-  num_comm_qubits: 2
-  T1: 1.e+12
-  T2: 1.e+12
+  electron_T1: 1.e+12
+  electron_T2: 1.e+12
+  carbon_T1: 10.e+6
+  carbon_T2: 10.e+6
   init_time: 1.e+1
   single_qubit_gate_time: 1.e+1
   two_qubit_gate_time: 1.e+1
@@ -13,15 +14,18 @@ stacks:
     qdevice_typ: nv
     qdevice_cfg: 
       <<: *qdevice_cfg
+    host_qnos_latency: 1e6
   - name: server
     qdevice_typ: nv
     qdevice_cfg: 
       <<: *qdevice_cfg
+    host_qnos_latency: 1e6
   
 link_cfg: &link_cfg
-  fidelity: 1.0
-  prob_success: 0.01
-  t_cycle: 1e3
+  fidelity: 0.75
+  # prob_success: 5.e-5  # 1 / 20_000
+  prob_success: 1
+  t_cycle: 5.e+3
 
 links:
   - stack1: client
diff --git a/examples/stack/fidelity_constraint/example_bqc_nv_constraint.py b/examples/stack/fidelity_constraint/example_bqc_nv_constraint.py
index 87b5553c..b1cee917 100644
--- a/examples/stack/fidelity_constraint/example_bqc_nv_constraint.py
+++ b/examples/stack/fidelity_constraint/example_bqc_nv_constraint.py
@@ -18,6 +18,7 @@
 from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
 
 # BQC example with a `min_fidelity_all_at_end` constraint on the entangled pairs.
+MAX_TRIES = 1000
 
 
 class ClientProgram(Program):
@@ -90,7 +91,7 @@ def post_create(_: BaseNetQASMConnection, q: Qubit, index: RegFuture):
             sequential=True,
             post_routine=post_create,
             min_fidelity_all_at_end=80,
-            max_tries=100,
+            max_tries=MAX_TRIES,
         )
 
         yield from conn.flush()
@@ -139,7 +140,11 @@ def run(
         csocket: ClassicalSocket = context.csockets[self.PEER]
 
         # Create EPR Pair
-        epr1, epr2 = epr_socket.recv_keep(2, min_fidelity_all_at_end=80, max_tries=100)
+        epr1, epr2 = epr_socket.recv_keep(
+            2,
+            min_fidelity_all_at_end=80,
+            max_tries=MAX_TRIES,
+        )
         epr2.cphase(epr1)
 
         yield from conn.flush()
@@ -243,15 +248,19 @@ def trap_round(
 
 
 if __name__ == "__main__":
-    num_times = 50
-    LogManager.set_log_level("WARNING")
+    # num_times = 50
+    # LogManager.set_log_level("WARNING")
+
+    num_times = 1
+    LogManager.set_log_level("DEBUG")
 
+    LogManager.log_to_file("dump_bqc_nv_constraint.log")
     ns.set_qstate_formalism(ns.qubits.qformalism.QFormalism.DM)
 
     cfg_file = os.path.join(os.path.dirname(__file__), "config_nv.yaml")
     cfg = StackNetworkConfig.from_file(cfg_file)
-    cfg.stacks[0].qdevice_cfg = NVQDeviceConfig.perfect_config()
-    cfg.stacks[1].qdevice_cfg = NVQDeviceConfig.perfect_config()
+    # cfg.stacks[0].qdevice_cfg = NVQDeviceConfig.perfect_config()
+    # cfg.stacks[1].qdevice_cfg = NVQDeviceConfig.perfect_config()
 
-    computation_round(cfg, num_times, alpha=PI_OVER_2, beta=PI_OVER_2)
-    # trap_round(cfg=cfg, num_times=num_times, dummy=2)
+    # computation_round(cfg, num_times, alpha=PI_OVER_2, beta=PI_OVER_2)
+    trap_round(cfg=cfg, num_times=num_times, dummy=2)
diff --git a/squidasm/run/stack/config.py b/squidasm/run/stack/config.py
index 1ec04180..05fae9e1 100644
--- a/squidasm/run/stack/config.py
+++ b/squidasm/run/stack/config.py
@@ -79,9 +79,9 @@ class NVQDeviceConfig(BaseModel):
     carbon_rot_y: int = 500_000
     carbon_rot_z: int = 500_000
     electron_init: int = 2_000
-    electron_rot_x: int = 5
-    electron_rot_y: int = 5
-    electron_rot_z: int = 5
+    electron_rot_x: int = 5_000
+    electron_rot_y: int = 5_000
+    electron_rot_z: int = 5_000
     ec_controlled_dir_x: int = 500_000
     ec_controlled_dir_y: int = 500_000
     measure: int = 3_700
@@ -110,6 +110,8 @@ class StackConfig(BaseModel):
     name: str
     qdevice_typ: str
     qdevice_cfg: Any
+    host_qnos_latency: float = 0.0
+    instr_latency: float = 0.0
 
     @classmethod
     def from_file(cls, path: str) -> StackConfig:
@@ -121,6 +123,8 @@ def perfect_generic_config(cls, name: str) -> StackConfig:
             name=name,
             qdevice_typ="generic",
             qdevice_cfg=GenericQDeviceConfig.perfect_config(),
+            host_qnos_latency=0.0,
+            instr_latency=0.0,
         )
 
 
@@ -166,6 +170,8 @@ class LinkConfig(BaseModel):
     stack2: str
     typ: str
     cfg: Any
+    host_host_latency: float = 0.0
+    qnos_qnos_latency: float = 0.0
 
     @classmethod
     def from_file(cls, path: str) -> LinkConfig:
@@ -173,7 +179,14 @@ def from_file(cls, path: str) -> LinkConfig:
 
     @classmethod
     def perfect_config(cls, stack1: str, stack2: str) -> LinkConfig:
-        return LinkConfig(stack1=stack1, stack2=stack2, typ="perfect", cfg=None)
+        return LinkConfig(
+            stack1=stack1,
+            stack2=stack2,
+            typ="perfect",
+            cfg=None,
+            host_host_latency=0.0,
+            qnos_qnos_latency=0.0,
+        )
 
 
 class StackNetworkConfig(BaseModel):
diff --git a/squidasm/run/stack/run.py b/squidasm/run/stack/run.py
index 9770864d..f5e4b331 100644
--- a/squidasm/run/stack/run.py
+++ b/squidasm/run/stack/run.py
@@ -4,6 +4,8 @@
 from typing import Any, Dict, List
 
 import netsquid as ns
+from netsquid.components.channel import Channel
+from netsquid.nodes.connections import DirectConnection
 from netsquid_magic.link_layer import (
     MagicLinkLayerProtocol,
     MagicLinkLayerProtocolWithSignaling,
@@ -49,22 +51,37 @@ def _setup_network(config: StackNetworkConfig) -> StackNetwork:
             if not isinstance(qdevice_cfg, NVQDeviceConfig):
                 qdevice_cfg = NVQDeviceConfig(**cfg.qdevice_cfg)
             qdevice = build_nv_qdevice(f"qdevice_{cfg.name}", cfg=qdevice_cfg)
-            stack = NodeStack(cfg.name, qdevice_type="nv", qdevice=qdevice)
+            stack = NodeStack(
+                cfg.name,
+                qdevice_type="nv",
+                qdevice=qdevice,
+                host_qnos_latency=cfg.host_qnos_latency,
+                instr_latency=cfg.instr_latency,
+            )
         elif cfg.qdevice_typ == "generic":
             qdevice_cfg = cfg.qdevice_cfg
             if not isinstance(qdevice_cfg, GenericQDeviceConfig):
                 qdevice_cfg = GenericQDeviceConfig(**cfg.qdevice_cfg)
             qdevice = build_generic_qdevice(f"qdevice_{cfg.name}", cfg=qdevice_cfg)
-            stack = NodeStack(cfg.name, qdevice_type="generic", qdevice=qdevice)
+            stack = NodeStack(
+                cfg.name,
+                qdevice_type="generic",
+                qdevice=qdevice,
+                host_qnos_latency=cfg.host_qnos_latency,
+                instr_latency=cfg.instr_latency,
+            )
         NetSquidContext.add_node(stack.node.ID, cfg.name)
         stacks[cfg.name] = stack
 
-    for (_, s1), (_, s2) in itertools.combinations(stacks.items(), 2):
-        s1.connect_to(s2)
-
     for link in config.links:
         stack1 = stacks[link.stack1]
         stack2 = stacks[link.stack2]
+        stack1.connect_to(
+            stack2,
+            host_host_delay=link.host_host_latency,
+            qnos_qnos_delay=link.qnos_qnos_latency,
+        )
+
         if link.typ == "perfect":
             link_dist = PerfectStateMagicDistributor(
                 nodes=[stack1.node, stack2.node], state_delay=1000.0
diff --git a/squidasm/sim/stack/common.py b/squidasm/sim/stack/common.py
index 8fb2aab2..07ee7dbe 100644
--- a/squidasm/sim/stack/common.py
+++ b/squidasm/sim/stack/common.py
@@ -6,7 +6,9 @@
 from netqasm.lang import operand
 from netqasm.lang.encoding import RegisterName
 from netqasm.sdk.shared_memory import Arrays, RegisterGroup, setup_registers
+from netsquid.components.channel import Channel
 from netsquid.components.component import Component, Port
+from netsquid.nodes.connections import DirectConnection
 from netsquid.protocols import Protocol
 
 from pydynaa import EventExpression
@@ -391,3 +393,14 @@ class NVPhysicalQuantumMemory(PhysicalQuantumMemory):
     def __init__(self, qubit_count: int) -> None:
         super().__init__(qubit_count)
         self._comm_qubit_ids: Set[int] = {0}
+
+
+class DelayedClassicalConnection(DirectConnection):
+    def __init__(self, name: str, delay: float) -> None:
+        chan1 = Channel(f"chan_1_{name}", delay=delay)
+        chan2 = Channel(f"chan_2_{name}", delay=delay)
+        super().__init__(name, channel_AtoB=chan1, channel_BtoA=chan2)
+
+
+class SubroutineAbortedError(RuntimeError):
+    pass
diff --git a/squidasm/sim/stack/connection.py b/squidasm/sim/stack/connection.py
index d551d8da..cfd5fc2e 100644
--- a/squidasm/sim/stack/connection.py
+++ b/squidasm/sim/stack/connection.py
@@ -21,7 +21,7 @@
     from netqasm.sdk.transpile import SubroutineTranspiler
     from squidasm.sim.stack.host import Host
 
-from squidasm.sim.stack.common import LogManager
+from squidasm.sim.stack.common import LogManager, SubroutineAbortedError
 
 from .context import NetSquidNetworkInfo
 
@@ -105,7 +105,11 @@ def commit_subroutine(
         )
 
         result = yield from self._host.receive_qnos_msg()
-        self._shared_memory = result
+        # TODO
+        if result == "abort":
+            raise SubroutineAbortedError
+        else:
+            self._shared_memory = result
 
     def flush(
         self, block: bool = True, callback: Optional[Callable] = None
diff --git a/squidasm/sim/stack/globals.py b/squidasm/sim/stack/globals.py
index c56297db..ff62f0be 100644
--- a/squidasm/sim/stack/globals.py
+++ b/squidasm/sim/stack/globals.py
@@ -17,6 +17,12 @@ class GlobalSimData:
     _NETWORK: Optional[StackNetwork] = None
     _BREAKPOINT_STATES: List[np.ndarray] = []
 
+    # Types of custom-defined event.
+    _CUSTOM_EVENT_TYPES: List[str] = []
+
+    # Number of times each custom-defined event has fired.
+    _CUSTOM_EVENT_COUNT: Dict[str, int] = {}
+
     @classmethod
     def set_network(cls, network: StackNetwork) -> None:
         cls._NETWORK = network
@@ -49,3 +55,29 @@ def get_quantum_state(cls, save: bool = False) -> T_QubitData:
     def get_last_breakpoint_state(cls) -> np.ndarray:
         assert len(cls._BREAKPOINT_STATES) > 0
         return cls._BREAKPOINT_STATES[-1]
+
+    @classmethod
+    def create_custom_event_type(cls, name: str) -> None:
+        assert name not in cls._CUSTOM_EVENT_TYPES
+        cls._CUSTOM_EVENT_TYPES.append(name)
+        cls._CUSTOM_EVENT_COUNT[name] = 0
+
+    @classmethod
+    def record_custom_event(cls, name: str) -> None:
+        assert name in cls._CUSTOM_EVENT_TYPES
+        cls._CUSTOM_EVENT_COUNT[name] += 1
+
+    @classmethod
+    def get_custom_event_count(cls, name: str) -> int:
+        assert name in cls._CUSTOM_EVENT_TYPES
+        return cls._CUSTOM_EVENT_COUNT[name]
+
+    @classmethod
+    def reset_custom_event_count(cls, name: str) -> None:
+        assert name in cls._CUSTOM_EVENT_TYPES
+        cls._CUSTOM_EVENT_COUNT[name] = 0
+
+    @classmethod
+    def remove_custom_event_type(cls, name: str) -> None:
+        assert name in cls._CUSTOM_EVENT_TYPES
+        cls._CUSTOM_EVENT_TYPES.remove(name)
diff --git a/squidasm/sim/stack/handler.py b/squidasm/sim/stack/handler.py
index c8b1beea..0c53ed9d 100644
--- a/squidasm/sim/stack/handler.py
+++ b/squidasm/sim/stack/handler.py
@@ -53,24 +53,16 @@ class HandlerComponent(Component):
     def __init__(self, node: Node) -> None:
         super().__init__(f"{node.name}_handler")
         self._node = node
-        self.add_ports(["proc_out", "proc_in"])
-        self.add_ports(["host_out", "host_in"])
+        self.add_ports(["proc"])
+        self.add_ports(["host"])
 
     @property
-    def processor_in_port(self) -> Port:
-        return self.ports["proc_in"]
+    def processor_port(self) -> Port:
+        return self.ports["proc"]
 
     @property
-    def processor_out_port(self) -> Port:
-        return self.ports["proc_out"]
-
-    @property
-    def host_in_port(self) -> Port:
-        return self.ports["host_in"]
-
-    @property
-    def host_out_port(self) -> Port:
-        return self.ports["host_out"]
+    def host_port(self) -> Port:
+        return self.ports["host"]
 
     @property
     def node(self) -> Node:
@@ -125,11 +117,11 @@ def __init__(
 
         self.add_listener(
             "host",
-            PortListener(self._comp.ports["host_in"], SIGNAL_HOST_HAND_MSG),
+            PortListener(self._comp.ports["host"], SIGNAL_HOST_HAND_MSG),
         )
         self.add_listener(
             "processor",
-            PortListener(self._comp.ports["proc_in"], SIGNAL_PROC_HAND_MSG),
+            PortListener(self._comp.ports["proc"], SIGNAL_PROC_HAND_MSG),
         )
 
         # Number of applications that were handled so far. Used as a unique ID for
@@ -176,13 +168,13 @@ def flavour(self, flavour: Optional[flavour.Flavour]) -> None:
         self._flavour = flavour
 
     def _send_host_msg(self, msg: Any) -> None:
-        self._comp.host_out_port.tx_output(msg)
+        self._comp.host_port.tx_output(msg)
 
     def _receive_host_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("host", SIGNAL_HOST_HAND_MSG))
 
     def _send_processor_msg(self, msg: str) -> None:
-        self._comp.processor_out_port.tx_output(msg)
+        self._comp.processor_port.tx_output(msg)
 
     def _receive_processor_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("processor", SIGNAL_PROC_HAND_MSG))
@@ -208,9 +200,11 @@ def init_new_app(self, max_qubits: int) -> int:
         self._logger.debug(f"registered app with ID {app_id}")
         return app_id
 
-    def open_epr_socket(self, app_id: int, socket_id: int, remote_id: int) -> None:
+    def open_epr_socket(
+        self, app_id: int, socket_id: int, remote_id: int, min_fidelity: int = 0
+    ) -> None:
         self._logger.debug(f"Opening EPR socket ({socket_id}, {remote_id})")
-        self.netstack.open_epr_socket(app_id, socket_id, remote_id)
+        self.netstack.open_epr_socket(app_id, socket_id, remote_id, min_fidelity)
 
     def add_subroutine(self, app_id: int, subroutine: Subroutine) -> None:
         self._applications[app_id].add_subroutine(subroutine)
@@ -219,12 +213,16 @@ def _deserialize_subroutine(self, msg: SubroutineMessage) -> Subroutine:
         # return deser_subroutine(msg.subroutine, flavour=flavour.NVFlavour())
         return deser_subroutine(msg.subroutine, flavour=self._flavour)
 
-    def clear_application(self, app_id: int) -> None:
+    def clear_application(self, app_id: int, remove_app: bool = True) -> None:
         for virt_id, phys_id in self.app_memories[app_id].qubit_mapping.items():
             self.app_memories[app_id].unmap_virt_id(virt_id)
             if phys_id is not None:
                 self.physical_memory.free(phys_id)
-        self.app_memories.pop(app_id)
+                # TODO
+                self.qnos.processor.qdevice.mem_positions[phys_id].in_use = False
+        # TODO comment
+        if remove_app:
+            self.app_memories.pop(app_id)
 
     def stop_application(self, app_id: int) -> None:
         self._logger.debug(f"stopping application with ID {app_id}")
@@ -237,7 +235,7 @@ def stop_application(self, app_id: int) -> None:
 
     def assign_processor(
         self, app_id: int, subroutine: Subroutine
-    ) -> Generator[EventExpression, None, AppMemory]:
+    ) -> Generator[EventExpression, None, Optional[AppMemory]]:
         """Tell the processor to execute a subroutine and wait for it to finish.
 
         :param app_id: ID of the application this subroutine is for
@@ -245,10 +243,15 @@ def assign_processor(
         """
         self._send_processor_msg(subroutine)
         result = yield from self._receive_processor_msg()
-        assert result == "subroutine done"
-        self._logger.debug(f"result: {result}")
-        app_mem = self.app_memories[app_id]
-        return app_mem
+        if result == "subroutine done":
+            self._logger.debug(f"result: {result}")
+            app_mem = self.app_memories[app_id]
+            return app_mem
+        else:
+            # TODO
+            assert result == "timeout"
+            self.clear_application(app_id, remove_app=False)
+            return None  # error
 
     def msg_from_host(self, msg: Message) -> None:
         """Handle a deserialized message from the Host."""
@@ -256,7 +259,9 @@ def msg_from_host(self, msg: Message) -> None:
             app_id = self.init_new_app(msg.max_qubits)
             self._send_host_msg(app_id)
         elif isinstance(msg, OpenEPRSocketMessage):
-            self.open_epr_socket(msg.app_id, msg.epr_socket_id, msg.remote_node_id)
+            self.open_epr_socket(
+                msg.app_id, msg.epr_socket_id, msg.remote_node_id, msg.min_fidelity
+            )
         elif isinstance(msg, SubroutineMessage):
             subroutine = self._deserialize_subroutine(msg)
             self.add_subroutine(subroutine.app_id, subroutine)
@@ -286,4 +291,8 @@ def run(self) -> Generator[EventExpression, None, None]:
                     if subrt is None:
                         break
                     app_mem = yield from self.assign_processor(app.id, subrt)
-                    self._send_host_msg(app_mem)
+                    # TODO
+                    if app_mem is not None:  # success
+                        self._send_host_msg(app_mem)
+                    else:
+                        self._send_host_msg("abort")
diff --git a/squidasm/sim/stack/host.py b/squidasm/sim/stack/host.py
index 4e22c305..2dbb6fb2 100644
--- a/squidasm/sim/stack/host.py
+++ b/squidasm/sim/stack/host.py
@@ -32,24 +32,16 @@ class HostComponent(Component):
 
     def __init__(self, node: Node) -> None:
         super().__init__(f"{node.name}_host")
-        self.add_ports(["qnos_in", "qnos_out"])
-        self.add_ports(["peer_in", "peer_out"])
+        self.add_ports(["qnos"])
+        self.add_ports(["peer"])
 
     @property
-    def qnos_in_port(self) -> Port:
-        return self.ports["qnos_in"]
+    def qnos_port(self) -> Port:
+        return self.ports["qnos"]
 
     @property
-    def qnos_out_port(self) -> Port:
-        return self.ports["qnos_out"]
-
-    @property
-    def peer_in_port(self) -> Port:
-        return self.ports["peer_in"]
-
-    @property
-    def peer_out_port(self) -> Port:
-        return self.ports["peer_out"]
+    def peer_port(self) -> Port:
+        return self.ports["peer"]
 
 
 class Host(ComponentProtocol):
@@ -66,11 +58,11 @@ def __init__(self, comp: HostComponent, qdevice_type: Optional[str] = "nv") -> N
 
         self.add_listener(
             "qnos",
-            PortListener(self._comp.ports["qnos_in"], SIGNAL_HAND_HOST_MSG),
+            PortListener(self._comp.ports["qnos"], SIGNAL_HAND_HOST_MSG),
         )
         self.add_listener(
             "peer",
-            PortListener(self._comp.ports["peer_in"], SIGNAL_HOST_HOST_MSG),
+            PortListener(self._comp.ports["peer"], SIGNAL_HOST_HOST_MSG),
         )
 
         if qdevice_type == "nv":
@@ -100,13 +92,13 @@ def compiler(self, typ: Optional[Type[SubroutineTranspiler]]) -> None:
         self._compiler = typ
 
     def send_qnos_msg(self, msg: bytes) -> None:
-        self._comp.qnos_out_port.tx_output(msg)
+        self._comp.qnos_port.tx_output(msg)
 
     def receive_qnos_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("qnos", SIGNAL_HAND_HOST_MSG))
 
     def send_peer_msg(self, msg: str) -> None:
-        self._comp.peer_out_port.tx_output(msg)
+        self._comp.peer_port.tx_output(msg)
 
     def receive_peer_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("peer", SIGNAL_HOST_HOST_MSG))
@@ -116,7 +108,7 @@ def run(self) -> Generator[EventExpression, None, None]:
 
         # Run a single program as many times as requested.
         while self._num_pending > 0:
-            self._logger.info(f"num pending: {self._num_pending}")
+            self._logger.warning(f"num pending: {self._num_pending}")
             self._num_pending -= 1
 
             assert self._program is not None
diff --git a/squidasm/sim/stack/netstack.py b/squidasm/sim/stack/netstack.py
index c12c17bf..c08ff483 100644
--- a/squidasm/sim/stack/netstack.py
+++ b/squidasm/sim/stack/netstack.py
@@ -6,6 +6,7 @@
 
 import netsquid as ns
 from netqasm.sdk.build_epr import (
+    SER_CREATE_IDX_MAX_TIME,
     SER_CREATE_IDX_NUMBER,
     SER_CREATE_IDX_TYPE,
     SER_RESPONSE_KEEP_IDX_BELL_STATE,
@@ -76,31 +77,22 @@ class NetstackComponent(Component):
     def __init__(self, node: Node) -> None:
         super().__init__(f"{node.name}_netstack")
         self._node = node
-        self.add_ports(["proc_out", "proc_in"])
-        self.add_ports(["peer_out", "peer_in"])
+        self.add_ports(["proc"])
+        self.add_ports(["peer"])
 
     @property
-    def processor_in_port(self) -> Port:
-        return self.ports["proc_in"]
+    def processor_port(self) -> Port:
+        return self.ports["proc"]
 
     @property
-    def processor_out_port(self) -> Port:
-        return self.ports["proc_out"]
-
-    @property
-    def peer_in_port(self) -> Port:
-        return self.ports["peer_in"]
-
-    @property
-    def peer_out_port(self) -> Port:
-        return self.ports["peer_out"]
+    def peer_port(self) -> Port:
+        return self.ports["peer"]
 
     @property
     def node(self) -> Node:
         return self._node
 
 
-@dataclass
 class EprSocket:
     """EPR Socket. Allows for EPR pair generation with a single remote node.
 
@@ -108,8 +100,22 @@ class EprSocket:
     sockets have a different ID, and may e.g be used for EPR generation requests
     with different parameters."""
 
-    socket_id: int
-    remote_id: int
+    def __init__(self, socket_id: int, remote_id: int, min_fidelity: int = 0) -> None:
+        self._socket_id = socket_id
+        self._remote_id = remote_id
+        self._min_fidelity = min_fidelity
+
+    @property
+    def socket_id(self) -> int:
+        return self._socket_id
+
+    @property
+    def remote_id(self) -> int:
+        return self._remote_id
+
+    @property
+    def min_fidelity(self) -> int:
+        return self._min_fidelity
 
 
 class Netstack(ComponentProtocol):
@@ -128,11 +134,11 @@ def __init__(self, comp: NetstackComponent, qnos: Qnos) -> None:
 
         self.add_listener(
             "processor",
-            PortListener(self._comp.processor_in_port, SIGNAL_PROC_NSTK_MSG),
+            PortListener(self._comp.processor_port, SIGNAL_PROC_NSTK_MSG),
         )
         self.add_listener(
             "peer",
-            PortListener(self._comp.peer_in_port, SIGNAL_PEER_NSTK_MSG),
+            PortListener(self._comp.peer_port, SIGNAL_PEER_NSTK_MSG),
         )
 
         self._egp: Optional[EgpProtocol] = None
@@ -146,7 +152,9 @@ def assign_ll_protocol(self, prot: MagicLinkLayerProtocolWithSignaling) -> None:
         """
         self._egp = EgpProtocol(self._comp.node, prot)
 
-    def open_epr_socket(self, app_id: int, socket_id: int, remote_node_id: int) -> None:
+    def open_epr_socket(
+        self, app_id: int, socket_id: int, remote_node_id: int, min_fidelity: int = 0
+    ) -> None:
         """Create a new EPR socket with the specified remote node.
 
         :param app_id: ID of the application that creates this EPR socket
@@ -155,11 +163,13 @@ def open_epr_socket(self, app_id: int, socket_id: int, remote_node_id: int) -> N
         """
         if app_id not in self._epr_sockets:
             self._epr_sockets[app_id] = []
-        self._epr_sockets[app_id].append(EprSocket(socket_id, remote_node_id))
+        self._epr_sockets[app_id].append(
+            EprSocket(socket_id, remote_node_id, min_fidelity)
+        )
 
     def _send_processor_msg(self, msg: str) -> None:
         """Send a message to the processor."""
-        self._comp.processor_out_port.tx_output(msg)
+        self._comp.processor_port.tx_output(msg)
 
     def _receive_processor_msg(self) -> Generator[EventExpression, None, str]:
         """Receive a message from the processor. Block until there is at least one
@@ -170,7 +180,7 @@ def _send_peer_msg(self, msg: str) -> None:
         """Send a message to the network stack of the other node.
 
         NOTE: for now we assume there is only one other node, which is 'the' peer."""
-        self._comp.peer_out_port.tx_output(msg)
+        self._comp.peer_port.tx_output(msg)
 
     def _receive_peer_msg(self) -> Generator[EventExpression, None, str]:
         """Receive a message from the network stack of the other node. Block until
@@ -198,7 +208,9 @@ def _read_request_args_array(self, app_id: int, array_addr: int) -> List[int]:
         app_mem.get_array(array_addr)
         return app_mem.get_array(array_addr)
 
-    def _construct_request(self, remote_id: int, args: List[int]) -> ReqCreateBase:
+    def _construct_request(
+        self, request: NetstackCreateRequest, args: List[int]
+    ) -> ReqCreateBase:
         """Construct a link layer request from application request info.
 
         :param remote_id: ID of remote node
@@ -210,27 +222,37 @@ def _construct_request(self, remote_id: int, args: List[int]) -> ReqCreateBase:
         assert typ is not None
         num_pairs = args[SER_CREATE_IDX_NUMBER]
         assert num_pairs is not None
+        max_time = args[SER_CREATE_IDX_MAX_TIME]
+
+        # Magic link layer needs max_time to be an integer
+        if max_time is None:
+            max_time = 0
 
-        # TODO
-        MINIMUM_FIDELITY = 0.99
+        epr_socket = self.find_epr_socket(
+            request.app_id, request.epr_socket_id, request.remote_node_id
+        )
+        assert epr_socket is not None
 
         if typ == 0:
             request = ReqCreateAndKeep(
-                remote_node_id=remote_id,
+                remote_node_id=request.remote_node_id,
                 number=num_pairs,
-                minimum_fidelity=MINIMUM_FIDELITY,
+                minimum_fidelity=epr_socket.min_fidelity,
+                max_time=max_time,
             )
         elif typ == 1:
             request = ReqMeasureDirectly(
-                remote_node_id=remote_id,
+                remote_node_id=request.remote_node_id,
                 number=num_pairs,
-                minimum_fidelity=MINIMUM_FIDELITY,
+                minimum_fidelity=epr_socket.min_fidelity,
+                max_time=max_time,
             )
         elif typ == 2:
             request = ReqRemoteStatePrep(
-                remote_node_id=remote_id,
+                remote_node_id=request.remote_node_id,
                 number=num_pairs,
-                minimum_fidelity=MINIMUM_FIDELITY,
+                minimum_fidelity=epr_socket.min_fidelity,
+                max_time=max_time,
             )
         else:
             raise ValueError(f"Unsupported create type {typ}")
@@ -302,6 +324,13 @@ def handle_create_ck_request(
         self._logger.info(f"splitting request into {num_pairs} 1-pair requests")
         request.number = 1
 
+        # Magic link layer protocol does not allow timeouts at this moment,
+        # so we handle them manually below.
+        max_time = request.max_time  # save original value
+        # print(f"request.max_time: {request.max_time}")
+        if request.max_time is not None:
+            request.max_time = 0
+
         start_time = ns.sim_time()
 
         for pair_index in range(num_pairs):
@@ -361,8 +390,22 @@ def handle_create_ck_request(
             )
 
             gen_duration_ns_float = ns.sim_time() - start_time
+            # self._logger.warning(f"gen duration (ns): {gen_duration_ns_float}")
             gen_duration_us_int = int(gen_duration_ns_float / 1000)
-            self._logger.info(f"gen duration (us): {gen_duration_us_int}")
+            self._logger.warning(f"gen duration (us): {gen_duration_us_int}")
+            # TODO comment
+            self._send_peer_msg(gen_duration_us_int)
+            self._send_peer_msg(max_time)
+
+            timeout = False
+
+            self._logger.info(f"max_time = {max_time}")
+            if max_time != 0 and gen_duration_us_int > max_time:
+                self._logger.info(
+                    f"EPR generation took {gen_duration_us_int} us "
+                    f"but max time was {max_time} us"
+                )
+                timeout = True
 
             # Length of response array slice for a single pair.
             slice_len = SER_RESPONSE_KEEP_LEN
@@ -386,7 +429,13 @@ def handle_create_ck_request(
                 f"wrote to @{req.result_array_addr}[{slice_len * pair_index}:"
                 f"{slice_len * pair_index + slice_len}] for app ID {req.app_id}"
             )
-            self._send_processor_msg("wrote to array")
+
+            # TODO
+            # ONLY trigger abort due to timeout at last pair
+            if timeout and pair_index == num_pairs - 1:
+                self._send_processor_msg("timeout")
+            else:
+                self._send_processor_msg("wrote to array")
 
     def handle_create_md_request(
         self, req: NetstackCreateRequest, request: ReqMeasureDirectly
@@ -484,7 +533,7 @@ def handle_create_request(
         args = self._read_request_args_array(req.app_id, req.arg_array_addr)
 
         # Create the link layer request object.
-        request = self._construct_request(req.remote_node_id, args)
+        request = self._construct_request(req, args)
 
         # Send it to the receiver node and wait for an acknowledgement.
         self._send_peer_msg(request)
@@ -573,9 +622,21 @@ def handle_receive_ck_request(
                 f"mapping virtual qubit {virt_id} to physical qubit {phys_id}"
             )
 
-            gen_duration_ns_float = ns.sim_time() - start_time
-            gen_duration_us_int = int(gen_duration_ns_float / 1000)
-            self._logger.info(f"gen duration (us): {gen_duration_us_int}")
+            # gen_duration_ns_float = ns.sim_time() - start_time
+            # gen_duration_us_int = int(gen_duration_ns_float / 1000)
+
+            # TODO comment
+            gen_duration_us_int = yield from self._receive_peer_msg()
+            max_time = yield from self._receive_peer_msg()
+
+            timeout = False
+
+            if max_time != 0 and gen_duration_us_int > max_time:
+                self._logger.info(
+                    f"EPR generation took {gen_duration_us_int} us "
+                    f"but max time was {max_time} us"
+                )
+                timeout = True
 
             # Length of response array slice for a single pair.
             slice_len = SER_RESPONSE_KEEP_LEN
@@ -598,7 +659,12 @@ def handle_receive_ck_request(
                 f"wrote to @{req.result_array_addr}[{slice_len * pair_index}:"
                 f"{slice_len * pair_index + slice_len}] for app ID {req.app_id}"
             )
-            self._send_processor_msg("wrote to array")
+
+            # ONLY trigger abort due to timeout at last pair
+            if timeout and pair_index == num_pairs - 1:
+                self._send_processor_msg("timeout")
+            else:
+                self._send_processor_msg("wrote to array")
 
     def handle_receive_md_request(
         self, req: NetstackReceiveRequest, request: ReqMeasureDirectly
diff --git a/squidasm/sim/stack/processor.py b/squidasm/sim/stack/processor.py
index 0e912eea..236dc434 100644
--- a/squidasm/sim/stack/processor.py
+++ b/squidasm/sim/stack/processor.py
@@ -29,7 +29,7 @@
 from netsquid.nodes import Node
 from netsquid.qubits import qubitapi
 
-from pydynaa import EventExpression
+from pydynaa import Entity, EventExpression, EventType
 from squidasm.sim.stack.common import (
     AllocError,
     AppMemory,
@@ -54,6 +54,11 @@
 PI = math.pi
 PI_OVER_2 = math.pi / 2
 
+INSTR_LATENCY_EVENT: EventType = EventType(
+    "INSTR_LATENCY_EVENT",
+    "end of waiting time that represents instruction processing latency",
+)
+
 
 class ProcessorComponent(Component):
     """NetSquid component representing a QNodeOS processor.
@@ -72,24 +77,16 @@ class ProcessorComponent(Component):
     def __init__(self, node: Node) -> None:
         super().__init__(f"{node.name}_processor")
         self._node = node
-        self.add_ports(["nstk_out", "nstk_in"])
-        self.add_ports(["hand_out", "hand_in"])
-
-    @property
-    def netstack_in_port(self) -> Port:
-        return self.ports["nstk_in"]
-
-    @property
-    def netstack_out_port(self) -> Port:
-        return self.ports["nstk_out"]
+        self.add_ports(["nstk"])
+        self.add_ports(["hand"])
 
     @property
-    def handler_in_port(self) -> Port:
-        return self.ports["hand_in"]
+    def netstack_port(self) -> Port:
+        return self.ports["nstk"]
 
     @property
-    def handler_out_port(self) -> Port:
-        return self.ports["hand_out"]
+    def handler_port(self) -> Port:
+        return self.ports["hand"]
 
     @property
     def qdevice(self) -> QuantumProcessor:
@@ -100,27 +97,31 @@ def node(self) -> Node:
         return self._node
 
 
-class Processor(ComponentProtocol):
+class Processor(ComponentProtocol, Entity):
     """NetSquid protocol representing a QNodeOS processor."""
 
-    def __init__(self, comp: ProcessorComponent, qnos: Qnos) -> None:
+    def __init__(
+        self, comp: ProcessorComponent, qnos: Qnos, instr_latency: float = 0.0
+    ) -> None:
         """Processor protocol constructor. Typically created indirectly through
         constructing a `Qnos` instance.
 
         :param comp: NetSquid component representing the processor
         :param qnos: `Qnos` protocol that owns this protocol
+        :param instr_latency: amount of time (ns) it takes to execute one instruction
         """
         super().__init__(name=f"{comp.name}_protocol", comp=comp)
         self._comp = comp
         self._qnos = qnos
+        self._instr_latency = instr_latency
 
         self.add_listener(
             "handler",
-            PortListener(self._comp.ports["hand_in"], SIGNAL_HAND_PROC_MSG),
+            PortListener(self._comp.ports["hand"], SIGNAL_HAND_PROC_MSG),
         )
         self.add_listener(
             "netstack",
-            PortListener(self._comp.ports["nstk_in"], SIGNAL_NSTK_PROC_MSG),
+            PortListener(self._comp.ports["nstk"], SIGNAL_NSTK_PROC_MSG),
         )
 
         self.add_signal(SIGNAL_MEMORY_FREED)
@@ -140,14 +141,19 @@ def qdevice(self) -> QuantumProcessor:
         """Get the NetSquid `QuantumProcessor` object of this node."""
         return self._comp.qdevice
 
+    @property
+    def instr_latency(self) -> float:
+        """Get the instruction execution latency."""
+        return self._instr_latency
+
     def _send_handler_msg(self, msg: str) -> None:
-        self._comp.handler_out_port.tx_output(msg)
+        self._comp.handler_port.tx_output(msg)
 
     def _receive_handler_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("handler", SIGNAL_HAND_PROC_MSG))
 
     def _send_netstack_msg(self, msg: str) -> None:
-        self._comp.netstack_out_port.tx_output(msg)
+        self._comp.netstack_port.tx_output(msg)
 
     def _receive_netstack_msg(self) -> Generator[EventExpression, None, str]:
         return (yield from self._receive_msg("netstack", SIGNAL_NSTK_PROC_MSG))
@@ -162,9 +168,13 @@ def run(self) -> Generator[EventExpression, None, None]:
             # assert isinstance(subroutine, Subroutine)
             self._logger.debug(f"received new subroutine from handler: {subroutine}")
 
-            yield from self.execute_subroutine(subroutine)
+            result = yield from self.execute_subroutine(subroutine)
 
-            self._send_handler_msg("subroutine done")
+            # TODO
+            if result == "timeout":
+                self._send_handler_msg("timeout")
+            else:
+                self._send_handler_msg("subroutine done")
 
     def execute_subroutine(
         self, subroutine: Subroutine
@@ -186,10 +196,15 @@ def execute_subroutine(
                 or isinstance(instr, core.BranchBinaryInstruction)
             ):
                 self._interpret_branch_instr(app_id, instr)
+                yield from self._add_instruction_latency()
             else:
                 generator = self._interpret_instruction(app_id, instr)
                 if generator:
-                    yield from generator
+                    result = yield from generator
+                    # TODO
+                    if result == "timeout":
+                        return "timeout"
+                yield from self._add_instruction_latency()
                 app_mem.increment_prog_counter()
 
     def _interpret_instruction(
@@ -242,6 +257,10 @@ def _interpret_instruction(
         else:
             raise RuntimeError(f"Invalid instruction {instr}")
 
+    def _add_instruction_latency(self) -> Generator[EventExpression, None, None]:
+        self._schedule_after(self.instr_latency, INSTR_LATENCY_EVENT)
+        yield EventExpression(source=self, event_type=INSTR_LATENCY_EVENT)
+
     def _interpret_breakpoint(
         self, app_id: int, instr: core.BreakpointInstruction
     ) -> None:
@@ -511,6 +530,8 @@ def _interpret_meas(
     def _interpret_create_epr(
         self, app_id: int, instr: core.CreateEPRInstruction
     ) -> None:
+        # self._logger.warning("create_epr")
+        GlobalSimData.record_custom_event("EPR attempt")
         app_mem = self.app_memories[app_id]
         remote_node_id = app_mem.get_reg_value(instr.remote_node_id)
         epr_socket_id = app_mem.get_reg_value(instr.epr_socket_id)
@@ -596,8 +617,13 @@ def _interpret_wait_all(
                     f"waiting for netstack to write to @{addr}[{start}:{end}] "
                     f"for app ID {app_id}"
                 )
-                yield from self._receive_netstack_msg()
-                self._logger.debug("netstack wrote something")
+                response = yield from self._receive_netstack_msg()
+                if response == "wrote to array":
+                    self._logger.debug("netstack wrote something")
+                else:
+                    assert response == "timeout"
+                    # TODO
+                    return "timeout"
             else:
                 break
         self._flush_netstack_msgs()
diff --git a/squidasm/sim/stack/qnos.py b/squidasm/sim/stack/qnos.py
index 23150be4..8b712f90 100644
--- a/squidasm/sim/stack/qnos.py
+++ b/squidasm/sim/stack/qnos.py
@@ -41,10 +41,10 @@ def __init__(self, node: Node) -> None:
         self._node = node
 
         # Ports for communicating with Host
-        self.add_ports(["host_out", "host_in"])
+        self.add_ports(["host"])
 
         # Ports for communicating with other nodes
-        self.add_ports(["peer_out", "peer_in"])
+        self.add_ports(["peer"])
 
         comp_handler = HandlerComponent(node)
         self.add_subcomponent(comp_handler, "handler")
@@ -55,25 +55,14 @@ def __init__(self, node: Node) -> None:
         comp_netstack = NetstackComponent(node)
         self.add_subcomponent(comp_netstack, "netstack")
 
-        self.netstack_comp.ports["peer_out"].forward_output(self.peer_out_port)
-        self.peer_in_port.forward_input(self.netstack_comp.ports["peer_in"])
+        self.netstack_comp.peer_port.forward_output(self.peer_port)
+        self.peer_port.forward_input(self.netstack_comp.peer_port)
 
-        self.handler_comp.ports["host_out"].forward_output(self.host_out_port)
-        self.host_in_port.forward_input(self.handler_comp.ports["host_in"])
+        self.handler_comp.host_port.forward_output(self.host_port)
+        self.host_port.forward_input(self.handler_comp.host_port)
 
-        self.handler_comp.processor_out_port.connect(
-            self.processor_comp.handler_in_port
-        )
-        self.handler_comp.processor_in_port.connect(
-            self.processor_comp.handler_out_port
-        )
-
-        self.processor_comp.netstack_out_port.connect(
-            self.netstack_comp.processor_in_port
-        )
-        self.processor_comp.netstack_in_port.connect(
-            self.netstack_comp.processor_out_port
-        )
+        self.handler_comp.processor_port.connect(self.processor_comp.handler_port)
+        self.processor_comp.netstack_port.connect(self.netstack_comp.processor_port)
 
     @property
     def handler_comp(self) -> HandlerComponent:
@@ -92,20 +81,12 @@ def qdevice(self) -> QuantumProcessor:
         return self.node.qmemory
 
     @property
-    def host_in_port(self) -> Port:
-        return self.ports["host_in"]
-
-    @property
-    def host_out_port(self) -> Port:
-        return self.ports["host_out"]
-
-    @property
-    def peer_in_port(self) -> Port:
-        return self.ports["peer_in"]
+    def host_port(self) -> Port:
+        return self.ports["host"]
 
     @property
-    def peer_out_port(self) -> Port:
-        return self.ports["peer_out"]
+    def peer_port(self) -> Port:
+        return self.ports["peer"]
 
     @property
     def node(self) -> Node:
@@ -115,7 +96,12 @@ def node(self) -> Node:
 class Qnos(Protocol):
     """NetSquid protocol representing a QNodeOS instance."""
 
-    def __init__(self, comp: QnosComponent, qdevice_type: Optional[str] = "nv") -> None:
+    def __init__(
+        self,
+        comp: QnosComponent,
+        qdevice_type: Optional[str] = "nv",
+        instr_latency: float = 0.0,
+    ) -> None:
         """Qnos protocol constructor.
 
         :param comp: NetSquid component representing the QNodeOS instance
@@ -128,10 +114,10 @@ def __init__(self, comp: QnosComponent, qdevice_type: Optional[str] = "nv") -> N
         self.handler = Handler(comp.handler_comp, self, qdevice_type)
         self.netstack = Netstack(comp.netstack_comp, self)
         if qdevice_type == "generic":
-            self.processor = GenericProcessor(comp.processor_comp, self)
+            self.processor = GenericProcessor(comp.processor_comp, self, instr_latency)
             self._physical_memory = PhysicalQuantumMemory(comp.qdevice.num_positions)
         elif qdevice_type == "nv":
-            self.processor = NVProcessor(comp.processor_comp, self)
+            self.processor = NVProcessor(comp.processor_comp, self, instr_latency)
             self._physical_memory = NVPhysicalQuantumMemory(comp.qdevice.num_positions)
         else:
             raise ValueError
diff --git a/squidasm/sim/stack/stack.py b/squidasm/sim/stack/stack.py
index 8a397ef3..b910dc20 100644
--- a/squidasm/sim/stack/stack.py
+++ b/squidasm/sim/stack/stack.py
@@ -3,8 +3,10 @@
 from typing import Dict, List, Optional
 
 from netsquid.components import QuantumProcessor
+from netsquid.components.channel import Channel
 from netsquid.components.component import Port
 from netsquid.nodes import Node
+from netsquid.nodes.connections import DirectConnection
 from netsquid.nodes.network import Network
 from netsquid.protocols import Protocol
 from netsquid_magic.link_layer import (
@@ -12,6 +14,7 @@
     MagicLinkLayerProtocolWithSignaling,
 )
 
+from squidasm.sim.stack.common import DelayedClassicalConnection
 from squidasm.sim.stack.host import Host, HostComponent
 from squidasm.sim.stack.qnos import Qnos, QnosComponent
 
@@ -39,6 +42,7 @@ def __init__(
         name: str,
         qdevice: QuantumProcessor,
         node_id: Optional[int] = None,
+        host_qnos_latency: float = 0.0,
     ) -> None:
         """ProcessingNode constructor. Typically created indirectly through
         constructing a `NodeStack`."""
@@ -51,17 +55,23 @@ def __init__(
         host_comp = HostComponent(self)
         self.add_subcomponent(host_comp, "host")
 
-        self.host_comp.ports["qnos_out"].connect(self.qnos_comp.ports["host_in"])
-        self.host_comp.ports["qnos_in"].connect(self.qnos_comp.ports["host_out"])
+        host_qnos_connection = DelayedClassicalConnection(
+            f"host_qnos_{self.name}", host_qnos_latency
+        )
+        self.add_subcomponent(host_qnos_connection, "host_qnos_connection")
+
+        self.host_comp.qnos_port.connect(host_qnos_connection.port_A)
+        self.qnos_comp.host_port.connect(host_qnos_connection.port_B)
 
         # Ports for communicating with other nodes
-        self.add_ports(["qnos_peer_out", "qnos_peer_in"])
-        self.add_ports(["host_peer_out", "host_peer_in"])
+        self.add_ports(["qnos_peer"])
+        self.add_ports(["host_peer"])
+
+        self.qnos_comp.peer_port.forward_output(self.qnos_peer_port)
+        self.qnos_peer_port.forward_input(self.qnos_comp.peer_port)
 
-        self.qnos_comp.peer_out_port.forward_output(self.qnos_peer_out_port)
-        self.qnos_peer_in_port.forward_input(self.qnos_comp.peer_in_port)
-        self.host_comp.peer_out_port.forward_output(self.host_peer_out_port)
-        self.host_peer_in_port.forward_input(self.host_comp.peer_in_port)
+        self.host_comp.peer_port.forward_output(self.host_peer_port)
+        self.host_peer_port.forward_input(self.host_comp.peer_port)
 
     @property
     def qnos_comp(self) -> QnosComponent:
@@ -76,20 +86,12 @@ def qdevice(self) -> QuantumProcessor:
         return self.qmemory
 
     @property
-    def host_peer_in_port(self) -> Port:
-        return self.ports["host_peer_in"]
+    def host_peer_port(self) -> Port:
+        return self.ports["host_peer"]
 
     @property
-    def host_peer_out_port(self) -> Port:
-        return self.ports["host_peer_out"]
-
-    @property
-    def qnos_peer_in_port(self) -> Port:
-        return self.ports["qnos_peer_in"]
-
-    @property
-    def qnos_peer_out_port(self) -> Port:
-        return self.ports["qnos_peer_out"]
+    def qnos_peer_port(self) -> Port:
+        return self.ports["qnos_peer"]
 
 
 class NodeStack(Protocol):
@@ -107,6 +109,8 @@ def __init__(
         qdevice_type: Optional[str] = "generic",
         qdevice: Optional[QuantumProcessor] = None,
         node_id: Optional[int] = None,
+        host_qnos_latency: float = 0.0,
+        instr_latency: float = 0.0,
         use_default_components: bool = True,
     ) -> None:
         """NodeStack constructor.
@@ -129,7 +133,7 @@ def __init__(
             self._node = node
         else:
             assert qdevice is not None
-            self._node = ProcessingNode(name, qdevice, node_id)
+            self._node = ProcessingNode(name, qdevice, node_id, host_qnos_latency)
 
         self._host: Optional[Host] = None
         self._qnos: Optional[Qnos] = None
@@ -139,7 +143,7 @@ def __init__(
         # created and added to this NodeStack.
         if use_default_components:
             self._host = Host(self.host_comp, qdevice_type)
-            self._qnos = Qnos(self.qnos_comp, qdevice_type)
+            self._qnos = Qnos(self.qnos_comp, qdevice_type, instr_latency)
 
     def assign_ll_protocol(self, prot: MagicLinkLayerProtocolWithSignaling) -> None:
         """Set the link layer protocol to use for entanglement generation.
@@ -180,13 +184,26 @@ def qnos(self) -> Qnos:
     def qnos(self, qnos: Qnos) -> None:
         self._qnos = qnos
 
-    def connect_to(self, other: NodeStack) -> None:
+    def connect_to(
+        self,
+        other: NodeStack,
+        host_host_delay: float = 1e6,
+        qnos_qnos_delay: float = 1e6,
+    ) -> None:
         """Create connections between ports of this NodeStack and those of
         another NodeStack."""
-        self.node.host_peer_out_port.connect(other.node.host_peer_in_port)
-        self.node.host_peer_in_port.connect(other.node.host_peer_out_port)
-        self.node.qnos_peer_out_port.connect(other.node.qnos_peer_in_port)
-        self.node.qnos_peer_in_port.connect(other.node.qnos_peer_out_port)
+
+        host_host_connection = DelayedClassicalConnection(
+            f"host_host_{self.node.name}_{other.node.name}", host_host_delay
+        )
+        self.node.host_peer_port.connect(host_host_connection.port_A)
+        other.node.host_peer_port.connect(host_host_connection.port_B)
+
+        qnos_qnos_connection = DelayedClassicalConnection(
+            f"qnos_qnos_{self.node.name}_{other.node.name}", qnos_qnos_delay
+        )
+        self.node.qnos_peer_port.connect(qnos_qnos_connection.port_A)
+        other.node.qnos_peer_port.connect(qnos_qnos_connection.port_B)
 
     def start(self) -> None:
         assert self._host is not None
diff --git a/tests/stack/classical/config.yaml b/tests/stack/classical/config.yaml
new file mode 100644
index 00000000..f98ad3b6
--- /dev/null
+++ b/tests/stack/classical/config.yaml
@@ -0,0 +1,31 @@
+qdevice_cfg: &qdevice_cfg
+  num_qubits: 2
+  num_comm_qubits: 2
+  T1: 1.e+8
+  T2: 1.e+8
+  init_time: 1.e+4
+  single_qubit_gate_time: 1.e+3
+  two_qubit_gate_time: 1.e+5
+  measurement_time: 1.e+4
+
+stacks:
+  - name: client
+    qdevice_typ: generic
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+  - name: server
+    qdevice_typ: generic
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+  
+link_cfg: &link_cfg
+  fidelity: 0.8
+  prob_success: 0.01
+  t_cycle: 1e3
+
+links:
+  - stack1: client
+    stack2: server
+    typ: depolarise
+    cfg:
+      <<: *link_cfg
\ No newline at end of file
diff --git a/tests/stack/classical/test_classical.py b/tests/stack/classical/test_classical.py
new file mode 100644
index 00000000..b6ecaf69
--- /dev/null
+++ b/tests/stack/classical/test_classical.py
@@ -0,0 +1,93 @@
+import os
+from typing import Any, Dict, Generator
+
+import netsquid as ns
+
+from pydynaa import EventExpression
+from squidasm.run.stack.config import StackNetworkConfig
+from squidasm.run.stack.run import run
+from squidasm.sim.stack.common import LogManager
+from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
+
+
+class ClientProgram(Program):
+    PEER = "server"
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="client_program",
+            parameters={},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=1,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        csocket = context.csockets[self.PEER]
+        csocket.send("hello")
+        response = yield from csocket.recv()
+        print(f"received response: {response}")
+        yield from context.connection.flush()
+
+        return {"response": response}
+
+
+class ServerProgram(Program):
+    PEER = "client"
+
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="server_program",
+            parameters={},
+            csockets=[self.PEER],
+            epr_sockets=[self.PEER],
+            max_qubits=1,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        csocket = context.csockets[self.PEER]
+        msg = yield from csocket.recv()
+        print(f"received message: {msg}")
+        csocket.send("hello back")
+        yield from context.connection.flush()
+
+        return {"msg": msg}
+
+
+def test_classical_messaging():
+    LogManager.set_log_level("WARNING")
+
+    num_times = 1
+    cfg = StackNetworkConfig.from_file(
+        os.path.join(os.getcwd(), os.path.dirname(__file__), "config.yaml")
+    )
+
+    host_host_latency = 2e5
+    cfg.links[0].host_host_latency = host_host_latency
+
+    client_program = ClientProgram()
+    server_program = ServerProgram()
+
+    client_results, server_results = run(
+        cfg, {"client": client_program, "server": server_program}, num_times
+    )
+
+    end_time = ns.sim_time()
+
+    # Verify program results.
+    assert server_results[0]["msg"] == "hello"
+    assert client_results[0]["response"] == "hello back"
+
+    # Verify that exactly two messages were sent from host to host,
+    # and that nothing else happened that took simulated time.
+    assert end_time == 2 * host_host_latency
+
+
+if __name__ == "__main__":
+    test_classical_messaging()
diff --git a/tests/stack/local/config.yaml b/tests/stack/local/config.yaml
new file mode 100644
index 00000000..8c8914f2
--- /dev/null
+++ b/tests/stack/local/config.yaml
@@ -0,0 +1,30 @@
+qdevice_cfg: &qdevice_cfg
+  num_qubits: 2
+  electron_T1: 1.e+12
+  electron_T2: 1.e+12
+  carbon_T1: 10.e+6
+  carbon_T2: 10.e+6
+
+stacks:
+  - name: client
+    qdevice_typ: nv
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+    host_qnos_latency: 1e6
+  - name: server
+    qdevice_typ: nv
+    qdevice_cfg: 
+      <<: *qdevice_cfg
+    host_qnos_latency: 1e6
+  
+link_cfg: &link_cfg
+  fidelity: 0.75
+  prob_success: 5.e-5  # 1 / 20_000
+  t_cycle: 5.e+3
+
+links:
+  - stack1: client
+    stack2: server
+    typ: depolarise
+    cfg:
+      <<: *link_cfg
\ No newline at end of file
diff --git a/tests/stack/local/test_local.py b/tests/stack/local/test_local.py
new file mode 100644
index 00000000..d6c6183a
--- /dev/null
+++ b/tests/stack/local/test_local.py
@@ -0,0 +1,64 @@
+import os
+from typing import Any, Dict, Generator
+
+import netsquid as ns
+from netqasm.sdk.qubit import Qubit
+
+from pydynaa import EventExpression
+from squidasm.run.stack.config import NVQDeviceConfig, StackNetworkConfig
+from squidasm.run.stack.run import run
+from squidasm.sim.stack.common import LogManager
+from squidasm.sim.stack.program import Program, ProgramContext, ProgramMeta
+
+
+class AliceProgram(Program):
+    @property
+    def meta(self) -> ProgramMeta:
+        return ProgramMeta(
+            name="alice_program",
+            parameters={},
+            csockets=[],
+            epr_sockets=[],
+            max_qubits=1,
+        )
+
+    def run(
+        self, context: ProgramContext
+    ) -> Generator[EventExpression, None, Dict[str, Any]]:
+        q = Qubit(context.connection)
+        yield from context.connection.flush()
+
+
+def test_local():
+    LogManager.set_log_level("DEBUG")
+
+    cfg = StackNetworkConfig.from_file(
+        os.path.join(os.getcwd(), os.path.dirname(__file__), "config.yaml")
+    )
+
+    instr_latency = 2e3
+    host_qnos_latency = 1e6
+    init_time = NVQDeviceConfig.perfect_config().electron_init
+
+    cfg.stacks[0].instr_latency = instr_latency
+    cfg.stacks[0].host_qnos_latency = host_qnos_latency
+
+    alice_program = AliceProgram()
+
+    run(cfg, {"client": alice_program})
+
+    end_time = ns.sim_time()
+
+    expected_time = (
+        3 * instr_latency  # 3 instructions
+        + 1 * init_time  # one of which is an 'init'
+        + 2 * host_qnos_latency  # InitNewApp + response
+        + 2 * host_qnos_latency  # Subroutine + response
+        + 1 * host_qnos_latency  # StopApp
+    )
+
+    assert end_time == expected_time
+
+
+if __name__ == "__main__":
+    test_local()