fn push_raw_transaction_to_bootloader_memory_v1<S: Storage, H: HistoryMode>(
    vm: &mut VmInstance<S, H>,
    tx: TransactionData,
    execution_mode: TxExecutionMode,
    predefined_overhead: u32,
    explicit_compressed_bytecodes: Option<Vec<CompressedBytecodeInfo>>,
) -> Vec<CompressedBytecodeInfo> {
    let tx_index_in_block = vm.bootloader_state.free_tx_index();
    let already_included_txs_size = vm.bootloader_state.free_tx_offset();

    let timestamp = Timestamp(vm.state.local_state.timestamp);
    let codes_for_decommiter = tx
        .factory_deps
        .iter()
        .map(|dep| bytecode_to_factory_dep(dep.clone()))
        .collect();

    let compressed_bytecodes = explicit_compressed_bytecodes.unwrap_or_else(|| {
        if tx.tx_type == L1_TX_TYPE {
            // L1 transactions do not need compression
            return vec![];
        }

        tx.factory_deps
            .iter()
            .filter_map(|bytecode| {
                if vm.is_bytecode_exists(&BytecodeHash::for_bytecode(bytecode).value()) {
                    return None;
                }
                bytecode::compress(bytecode.clone()).ok()
            })
            .collect()
    });
    let compressed_len = compressed_bytecodes
        .iter()
        .map(|bytecode| bytecode.compressed.len())
        .sum();

    vm.state
        .decommittment_processor
        .populate(codes_for_decommiter, timestamp);

    let block_gas_price_per_pubdata = vm.block_context.context.block_gas_price_per_pubdata();
    let trusted_ergs_limit = tx.trusted_gas_limit(block_gas_price_per_pubdata as u32);
    let encoded_tx = tx.into_tokens();
    let encoded_tx_size = encoded_tx.len();

    let previous_bytecodes = vm.bootloader_state.get_compressed_bytecodes();

    let bootloader_memory = get_bootloader_memory_for_encoded_tx(
        encoded_tx,
        tx_index_in_block,
        execution_mode,
        already_included_txs_size,
        0,
        predefined_overhead,
        trusted_ergs_limit,
        previous_bytecodes,
        &compressed_bytecodes,
    );

    vm.state.memory.populate_page(
        BOOTLOADER_HEAP_PAGE as usize,
        bootloader_memory,
        Timestamp(vm.state.local_state.timestamp),
    );
    vm.bootloader_state.add_tx_data(encoded_tx_size);
    vm.bootloader_state.add_compressed_bytecode(compressed_len);
    compressed_bytecodes
}
Contains a bug in the bytecode compression.
core/lib/multivm/src/versions/vm_m6/vm_with_bootloader.rs