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: compilation.rs
    path of file: ./repos/nearcore/runtime/near-vm/tests/compilers
    
    the code of the file until where you have to start completion: use std::sync::Arc;

use near_vm_compiler::CompileError;
use near_vm_engine::universal::{LimitedMemoryPool, Universal};
use near_vm_test_api::*;
use near_vm_vm::Artifact;

f
    
fn profiling() {
    let wat = r#"
       (import "env" "impf" (func))
       (func $f0)
       (func (export "f1"))
       (func (export "f2"))
       (func (export "f3"))
    "#;
    let wasm = wat2wasm(wat.as_bytes()).unwrap();
    let compiler = Singlepass::default();
    let pool = LimitedMemoryPool::new(1, 0x10000).unwrap();
    let engine = Arc::new(Universal::new(compiler).code_memory_pool(pool).engine());
    let store = Store::new(Arc::clone(&engine));
    match compile_uncached(&store, &engine, &wasm, false) {
        Ok(art) => unsafe {
            let serialized = art.serialize().unwrap();
            let executable =
                near_vm_engine::universal::UniversalExecutableRef::deserialize(&serialized)
                    .unwrap();
            let artifact = engine.load_universal_executable_ref(&executable).unwrap();
            let info = artifact
                .functions()
                .iter()
                .filter_map(|(idx, _)| {
                    let extent = artifact.function_extent(idx)?;
                    let idx = artifact.import_counts().function_index(idx);
                    let name = executable.function_name(idx)?;
                    Some((name, extent))
                })
                .collect::<Vec<_>>();
            assert_eq!(4, info.len());
            assert_eq!("f0", info[0].0);
            assert_eq!("f1", info[1].0);
            assert_eq!("f2", info[2].0);
            assert_eq!("f3", info[3].0);
        },
        Err(_) => {
            assert!(false)
        }
    }
}