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: selectors.rs
    path of file: ./repos/heimdall-rs/crates/common/src/ether
    
    the code of the file until where you have to start completion: use std::{
    collections::{HashMap, HashSet},
    sync::{Arc, Mutex},
    time::Duration,
};

use indicatif::ProgressBar;
use tokio::task;
use tracing::trace;

use crate::{error::E
    
pub fn find_function_selectors(evm: &VM, assembly: &str) -> HashMap<String, u128> {
    let mut function_selectors = HashMap::new();
    let mut handled_selectors = HashSet::new();

    // search through assembly for PUSHN (where N <= 4) instructions, optimistically assuming that
    // they are function selectors
    let assembly: Vec<String> = assembly.split('\n').map(|line| line.trim().to_string()).collect();
    for line in assembly.iter() {
        let instruction_args: Vec<String> = line.split(' ').map(|arg| arg.to_string()).collect();

        if instruction_args.len() >= 2 {
            let instruction = instruction_args[1].clone();

            if &instruction == "PUSH4" {
                let function_selector = instruction_args[2].clone();

                // check if this function selector has already been handled
                if handled_selectors.contains(&function_selector) {
                    continue;
                }

                trace!(
                    "optimistically assuming instruction {} {} {} is a function selector",
                    instruction_args[0],
                    instruction_args[1],
                    instruction_args[2]
                );

                // add the function selector to the handled selectors
                handled_selectors.insert(function_selector.clone());

                // get the function's entry point
                let function_entry_point =
                    match resolve_entry_point(&evm.clone(), &function_selector) {
                        0 => continue,
                        x => x,
                    };

                trace!(
                    "found function selector {} at entry point {}",
                    function_selector,
                    function_entry_point
                );

                function_selectors.insert(function_selector, function_entry_point);
            }
        }
    }
    function_selectors
}