diff --git a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
index beb72d87870..56203eb6601 100644
--- a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
+++ b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
@@ -43,14 +43,12 @@ test_cases.forEach((testInfo) => {
     const program = new Noir(noir_program);
 
     // JS Proving
-
     const prover_toml = readFileSync(resolve(`${base_relative_path}/${test_case}/Prover.toml`)).toString();
     const inputs = toml.parse(prover_toml);
     const { witness } = await program.execute(inputs);
     console.log(witness);
     const backend = new UltraHonkBackend(noir_program.bytecode);
     const proofData = await backend.generateProof(witness, { keccakZK: true });
-
     // JS verification
 
     const verified = await backend.verifyProof(proofData, { keccakZK: true });
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 12e751174b0..1faba6d1cac 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -58,7 +58,7 @@ pub const NOIRC_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const NOIR_ARTIFACT_VERSION_STRING: &str =
     concat!(env!("CARGO_PKG_VERSION"), "+", env!("GIT_COMMIT"));
 
-#[derive(Args, Clone, Debug, Default)]
+#[derive(Args, Clone, Debug)]
 pub struct CompileOptions {
     /// Specify the backend expression width that should be targeted
     #[arg(long, value_parser = parse_expression_width)]
@@ -232,6 +232,47 @@ pub struct CompileOptions {
     pub disable_comptime_printing: bool,
 }
 
+impl Default for CompileOptions {
+    fn default() -> Self {
+        Self {
+            expression_width: None,
+            bounded_codegen: false,
+            force_compile: false,
+            show_ssa: false,
+            show_ssa_pass: Vec::new(),
+            with_ssa_locations: false,
+            show_contract_fn: None,
+            skip_ssa_pass: Vec::new(),
+            emit_ssa: false,
+            minimal_ssa: false,
+            show_brillig: false,
+            print_acir: false,
+            benchmark_codegen: false,
+            deny_warnings: false,
+            silence_warnings: false,
+            show_monomorphized: false,
+            instrument_debug: false,
+            force_brillig: false,
+            debug_comptime_in_file: None,
+            show_artifact_paths: false,
+            skip_underconstrained_check: false,
+            skip_brillig_constraints_check: false,
+            enable_brillig_debug_assertions: false,
+            count_array_copies: false,
+            enable_brillig_constraints_check_lookback: false,
+            inliner_aggressiveness: i64::MAX,
+            constant_folding_max_iter: CONSTANT_FOLDING_MAX_ITER,
+            small_function_max_instructions: INLINING_MAX_INSTRUCTIONS,
+            max_bytecode_increase_percent: None,
+            pedantic_solving: false,
+            debug_compile_stdin: false,
+            unstable_features: Vec::new(),
+            no_unstable_features: false,
+            disable_comptime_printing: false,
+        }
+    }
+}
+
 impl CompileOptions {
     pub fn as_ssa_options(&self, package_build_path: PathBuf) -> SsaEvaluatorOptions {
         SsaEvaluatorOptions {
diff --git a/compiler/noirc_evaluator/src/acir/acir_context/mod.rs b/compiler/noirc_evaluator/src/acir/acir_context/mod.rs
index cc0c74b1384..5f2cdfa05af 100644
--- a/compiler/noirc_evaluator/src/acir/acir_context/mod.rs
+++ b/compiler/noirc_evaluator/src/acir/acir_context/mod.rs
@@ -133,6 +133,13 @@ impl<F: AcirField> AcirContext<F> {
             return Ok(());
         }
 
+        if let Some(w) = self.var_to_expression(lhs)?.to_witness() {
+            if self.acir_ir.input_witnesses.contains(&w) {
+                //Input witnesses are not replaced
+                return Ok(());
+            }
+        }
+
         let lhs_data = self.vars.remove(&lhs).ok_or_else(|| InternalError::UndeclaredAcirVar {
             call_stack: self.get_call_stack(),
         })?;
@@ -1317,11 +1324,9 @@ impl<F: AcirField> AcirContext<F> {
     /// Terminates the context and takes the resulting `GeneratedAcir`
     pub(crate) fn finish(
         mut self,
-        inputs: Vec<Witness>,
         return_values: Vec<Witness>,
         warnings: Vec<SsaReport>,
     ) -> GeneratedAcir<F> {
-        self.acir_ir.input_witnesses = inputs;
         self.acir_ir.return_witnesses = return_values;
         self.acir_ir.warnings = warnings;
         self.acir_ir
diff --git a/compiler/noirc_evaluator/src/acir/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs
index 3c9b107f2b5..e5bf00d116f 100644
--- a/compiler/noirc_evaluator/src/acir/mod.rs
+++ b/compiler/noirc_evaluator/src/acir/mod.rs
@@ -181,7 +181,9 @@ impl<'a> Context<'a> {
     ) -> Result<GeneratedAcir<FieldElement>, RuntimeError> {
         let dfg = &main_func.dfg;
         let entry_block = &dfg[main_func.entry_block()];
-        let input_witness = self.convert_ssa_block_params(entry_block.parameters(), dfg)?;
+        self.acir_context.acir_ir.input_witnesses =
+            self.convert_ssa_block_params(entry_block.parameters(), dfg)?;
+
         let num_return_witnesses =
             self.get_num_return_witnesses(entry_block.unwrap_terminator(), dfg);
 
@@ -257,7 +259,6 @@ impl<'a> Context<'a> {
 
         // Add the warnings from the alter Ssa passes
         Ok(self.acir_context.finish(
-            input_witness,
             // Don't embed databus return witnesses into the circuit.
             if self.data_bus.return_data.is_some() { Vec::new() } else { return_witnesses },
             warnings,
@@ -276,7 +277,7 @@ impl<'a> Context<'a> {
         })?;
         let arguments = self.gen_brillig_parameters(dfg[main_func.entry_block()].parameters(), dfg);
 
-        let witness_inputs = self.acir_context.extract_witnesses(&inputs);
+        self.acir_context.acir_ir.input_witnesses = self.acir_context.extract_witnesses(&inputs);
         let returns = main_func.returns().unwrap_or_default();
 
         let outputs: Vec<AcirType> =
@@ -311,7 +312,7 @@ impl<'a> Context<'a> {
             .map(|(value, _)| self.acir_context.var_to_witness(value))
             .collect::<Result<_, _>>()?;
 
-        let generated_acir = self.acir_context.finish(witness_inputs, return_witnesses, Vec::new());
+        let generated_acir = self.acir_context.finish(return_witnesses, Vec::new());
 
         assert_eq!(
             generated_acir.opcodes().len(),
diff --git a/compiler/noirc_evaluator/src/acir/tests/mod.rs b/compiler/noirc_evaluator/src/acir/tests/mod.rs
index 39bf3161b5d..8aff1c45741 100644
--- a/compiler/noirc_evaluator/src/acir/tests/mod.rs
+++ b/compiler/noirc_evaluator/src/acir/tests/mod.rs
@@ -293,6 +293,34 @@ fn derive_pedersen_generators_requires_constant_input() {
         .expect_err("Should fail with assert constant");
 }
 
+#[test]
+fn databus() {
+    let src = "
+    acir(inline) predicate_pure fn main f0 {
+        b0(v0: u32, v1: u32):
+            v2 = cast v0 as Field
+            v3 = make_array [v2] : [Field; 1]
+            constrain v0 == u32 0
+            v4 = add v0, v1
+            return v4
+        }
+    ";
+    let program = ssa_to_acir_program(src);
+
+    // Check that w0 is not replaced
+    assert_circuit_snapshot!(program, @r"
+    func 0
+    private parameters: [w0, w1]
+    public parameters: []
+    return values: [w2]
+    BLACKBOX::RANGE input: w1, bits: 32
+    ASSERT w0 = 0
+    ASSERT w3 = w0 + w1
+    BLACKBOX::RANGE input: w3, bits: 32
+    ASSERT w2 = w3
+    ");
+}
+
 /// Convert the SSA input into ACIR and use ACVM to execute it
 /// Returns the ACVM execution status and the value of the 'output' witness value,
 /// unless the provided output is None or the ACVM fails during execution.