You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: genesis.rs
    path of file: ./repos/Tuxedo/tuxedo-core/src
    
    the code of the file until where you have to start completion: //! Custom GenesisBlockBuilder for Tuxedo, to allow extrinsics to be added to the genesis block.

use crate::{
    ensure,
    types::{Output, OutputRef, Transaction},
    ConstraintChecker, Verifier, EXTRINSIC_KEY, LOG_TARGET,
};
use parity_scale_codec::{Decode, Encode};
use sc_chain_spec::BuildGenesisBlock;
use sc_client_api::backend::{Backend, BlockImportOperation};
use sc_executor::RuntimeVersionOf;
use serde::{Deserialize, Serialize};
use sp_core::{storage::Storage, traits::CodeExecutor};
use sp_runtime::{
    traits::{BlakeTwo256, Block as BlockT, Hash as HashT, Header as HeaderT, Zero},
    BuildStorage,
};
use std::sync::Arc;

pub struct TuxedoGenesisBlockBuilder<
    'a,
    Block: BlockT,
    B: Backend<Block>,
    E: RuntimeVersionOf + CodeExecutor,
> {
    build_ge
    
    fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
        // The wasm binary is stored under a special key.
        storage.top.insert(
            sp_storage::well_known_keys::CODE.into(),
            self.wasm_binary.clone(),
        );

        // The transactions are stored under a special key.
        storage
            .top
            .insert(EXTRINSIC_KEY.to_vec(), self.genesis_transactions.encode());

        let mut finished_with_opening_inherents = false;

        for tx in self.genesis_transactions.iter() {
            // Enforce that inherents are in the right place
            let current_tx_is_inherent = tx.checker.is_inherent();
            if current_tx_is_inherent && finished_with_opening_inherents {
                return Err(
                    "Tried to execute opening inherent after switching to non-inherents.".into(),
                );
            }
            if !current_tx_is_inherent && !finished_with_opening_inherents {
                // This is the first non-inherent, so we update our flag and continue.
                finished_with_opening_inherents = true;
            }
            // Enforce that transactions do not have any inputs or peeks.
            ensure!(
                tx.inputs.is_empty() && tx.peeks.is_empty(),
                "Genesis transactions must not have any inputs or peeks."
            );
            // Insert the outputs into the storage.
            let tx_hash = BlakeTwo256::hash_of(&tx.encode());
            for (index, utxo) in tx.outputs.iter().enumerate() {
                let output_ref = OutputRef {
                    tx_hash,
                    index: index as u32,
                };
                storage.top.insert(output_ref.encode(), utxo.encode());
            }
        }

        Ok(())
    }