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: main.rs
    path of file: ./repos/zenoh-flow/zenoh-flow-standalone-runtime/src
    
    the code of the file until where you have to start completion: //
// Copyright (c
    
async fn main() {
    let _ = tracing_subscriber::fmt::try_init();
    let cli = Cli::parse();

    let extensions = match cli.extensions {
        Some(extensions_path) => {
            let (extensions, _) = zenoh_flow_commons::try_parse_from_file::<Extensions>(
                extensions_path.as_os_str(),
                Vars::default(),
            )
            .context(format!(
                "Failed to load Loader configuration from < {} >",
                &extensions_path.display()
            ))
            .unwrap();

            extensions
        }
        None => Extensions::default(),
    };

    let loader = Loader::with_extensions(extensions);

    let vars = match cli.vars {
        Some(v) => Vars::from(v),
        None => Vars::default(),
    };

    let (data_flow, vars) =
        zenoh_flow_commons::try_parse_from_file::<DataFlowDescriptor>(cli.flow.as_os_str(), vars)
            .context(format!(
                "Failed to load data flow descriptor from < {} >",
                &cli.flow.display()
            ))
            .unwrap();

    let flattened_flow = FlattenedDataFlowDescriptor::try_flatten(data_flow, vars)
        .context(format!(
            "Failed to flattened data flow extracted from < {} >",
            &cli.flow.display()
        ))
        .unwrap();

    let hlc = Arc::new(uhlc::HLC::default());

    let session = zenoh::open(zenoh::peer()).res().await.unwrap().into_arc();
    let runtime = Runtime::new(
        RuntimeId::rand(),
        "zenoh-flow-standalone-runtime".into(),
        loader,
        hlc,
        session,
    );

    let record = DataFlowRecord::try_new(&flattened_flow, runtime.id())
        .context("Failed to create a Record from the flattened data flow descriptor")
        .unwrap();

    let instance_id = record.instance_id().clone();
    let record_name = record.name().clone();
    runtime
        .try_load_data_flow(record)
        .await
        .context("Failed to load Record")
        .unwrap();

    runtime
        .try_start_instance(&instance_id)
        .await
        .unwrap_or_else(|e| panic!("Failed to start data flow < {} >: {:?}", &instance_id, e));

    let mut stdin = async_std::io::stdin();
    let mut input = [0_u8];
    println!(
        r#"
    The flow ({}) < {} > was successfully started.

    To abort its execution, simply enter 'q'.
    "#,
        record_name, instance_id
    );

    loop {
        let _ = stdin.read_exact(&mut input).await;
        if input[0] == b'q' {
            break;
        }
    }

    runtime
        .try_delete_instance(&instance_id)
        .await
        .unwrap_or_else(|e| panic!("Failed to delete data flow < {} >: {:?}", &instance_id, e));
}