#[jolt::provable(memory_size = 10240, max_trace_length = 65536)]
fn fib(n: u32) -> u128 {
    let a: u128 = 0;
    let mut b: u128 = 1;

    start_cycle_tracking("fib_loop"); // Use `start_cycle_tracking("{name}")` to start a cycle span
    b = a + b;
    end_cycle_tracking("fib_loop"); // Use `end_cycle_tracking("{name}")` to end a cycle span
    b
}

let preprocessing = JoltRV64IMAC::prover_preprocess(
        bytecode.clone(), // We have already described this 
        program_io.memory_layout.clone(), // See below
        init_memory_state, //`vec<(u64, u8)>` of address value pairs.
        trace.len().next_power_of_two(), // This will be 64 for us given we had 63 virtual instructions. 
    );

pub struct MemoryLayout {
    /// The total size of the elf's sections, including the .text, .data, .rodata, and .bss sections.
    pub program_size: u64,
    pub max_trusted_advice_size: u64,
    pub trusted_advice_start: u64,
    pub trusted_advice_end: u64,
    pub max_untrusted_advice_size: u64,
    pub untrusted_advice_start: u64,
    pub untrusted_advice_end: u64,
    pub max_input_size: u64,
    pub max_output_size: u64,
    pub input_start: u64,
    pub input_end: u64,
    pub output_start: u64,
    pub output_end: u64,
    pub stack_size: u64,
    /// Stack starts from (RAM_START_ADDRESS + `program_size` + `stack_size`) and grows in descending addresses by `stack_size` bytes.
    pub stack_end: u64,
    pub memory_size: u64,
    /// Heap starts just after the start of the stack and is `memory_size` bytes.
    pub memory_end: u64,
    pub panic: u64,
    pub termination: u64,
    /// End of the memory region containing inputs, outputs, the panic bit,
    /// and the termination bit
    pub io_end: u64,
}

    #[tracing::instrument(skip_all, name = "Jolt::prover_preprocess")]
    fn prover_preprocess(
        bytecode: Vec<Instruction>,
        memory_layout: MemoryLayout,
        memory_init: Vec<(u64, u8)>,
        max_trace_length: usize,
    ) -> JoltProverPreprocessing<F, PCS> {
        let shared = Self::shared_preprocess(bytecode, memory_layout, memory_init); // <- we care about this only

        let max_T: usize = max_trace_length.next_power_of_two();

        // Ignored for this post
        let generators = PCS::setup_prover(DTH_ROOT_OF_K.log_2() + max_T.log_2());

        JoltProverPreprocessing { generators, shared }
    }

fn shared_preprocess(
        bytecode: Vec<Instruction>,
        memory_layout: MemoryLayout,
        memory_init: Vec<(u64, u8)>,
    ) -> JoltSharedPreprocessing {
        let bytecode_preprocessing = BytecodePreprocessing::preprocess(bytecode); // LINE 1 
        let ram_preprocessing = RAMPreprocessing::preprocess(memory_init); // LINE 2

        JoltSharedPreprocessing {
            memory_layout,
            bytecode: bytecode_preprocessing,
            ram: ram_preprocessing,
        }
    }

let (jolt_proof, program_io, _, _) = JoltRV64IMAC::prove(
            &preprocessing, // what we discussed above + crypto commitment mallarkey
            elf_contents, // the binary file in bytes
            &serialized_input, // This is the postcard thing we called fib with see part a of day 1 post i.e n 
            &[], // no trusted or untrusted advice for now
            &[],
            None,
        );

let state_manager = StateManager::new_prover(
                preprocessing, // what we discussed above
                trace, // the dynamic trace discussed in detail in part 1
                program_io.clone(), // see above
                trusted_advice_commitment, // There was no trusted advice in our example
                final_memory_state, // The final Vec<(u64)> state of memory
            );
            // We will spend ALOT of time here
            let (proof, debug_info) = JoltDAG::prove(state_manager).ok().unwrap();
            ```

where the `program_io` is given by the following struct 
```rust
pub struct JoltDevice {
    pub inputs: Vec<u8>, // the post card bit of our input n
    pub trusted_advice: Vec<u8>, // These were []
    pub untrusted_advice: Vec<u8>, // These were []
    pub outputs: Vec<u8>, // the final answer b
    pub panic: bool,
    pub memory_layout: MemoryLayout,
}

    let _guard = (
    AllCommittedPolynomials::initialize(compute_d_parameter(ram_K), bytecode_d), // <--- Focus here
);

let opening_proof_hints = Self::generate_and_commit_polynomials(&mut state_manager)?;

let opening_proof_hints = Self::generate_and_commit_polynomials(&mut state_manager)?;

let mut polynomials = vec![
    CommittedPolynomial::RdInc,
    CommittedPolynomial::RamInc,
    CommittedPolynomial::InstructionRa(0),
    CommittedPolynomial::InstructionRa(1),
    CommittedPolynomial::InstructionRa(2),
    CommittedPolynomial::InstructionRa(3),
    CommittedPolynomial::InstructionRa(4),
    CommittedPolynomial::InstructionRa(5),
    CommittedPolynomial::InstructionRa(6),
    CommittedPolynomial::InstructionRa(7),
    CommittedPolynomial::InstructionRa(8),
    CommittedPolynomial::InstructionRa(9),
    CommittedPolynomial::InstructionRa(10),
    CommittedPolynomial::InstructionRa(11),
    CommittedPolynomial::InstructionRa(12),
    CommittedPolynomial::InstructionRa(13),
    CommittedPolynomial::InstructionRa(14),
    CommittedPolynomial::InstructionRa(15),
];
for i in 0..ram_d {
    polynomials.push(CommittedPolynomial::RamRa(i));
}
for i in 0..bytecode_d {
    polynomials.push(CommittedPolynomial::BytecodeRa(i));
}