fn decript_message(mut mes: Vec<(i64, usize)>) -> Vec<(i64, usize)> {
    
    let n = mes.len(); 

    for _ in 0..10 {

        let mut index = 0; 

        while index < n {

            // look for current index
            let i = mes.iter().position(|elem| elem.1 == index).unwrap(); 

            let e = mes[i].0; 
            let rang_num = mes[i].1;  

            if e == 0 {
                println!("{}, {}, {}", e, i, rang_num); 
            }

            if e > 0 {


                let mut new_index = i as i64 + e;


                /*
                let mut to_add = new_index / mes.len() as i64;
                while {
                    to_add = to_add / mes.len() as i64; 
                    to_add >= mes.len() as i64

                } {}
                */                
                
                //let to_add = new_index / mes.len() as i64; 
                //new_index = (new_index % mes.len() as i64) + to_add;  
                
                /*
                while new_index >= mes.len() as i64 {
                    new_index -= mes.len() as i64; 
                    new_index += 1; 
                } 
                */
                mes.remove(i); 
                mes.insert(new_index as usize, (e, rang_num)); 
                
                
            } else if e < 0 {

                let mut new_index = i as i64 + e;
                //let to_sub = new_index.abs() / mes.len() as i64;
                //new_index = (new_index % mes.len() as i64) - to_sub;   

                while new_index < 0 {
                    new_index += mes.len() as i64; 
                    new_index -= 1; 
                } 
                
                mes.remove(i);
                mes.insert(new_index as usize, (e, rang_num)); 


            }
            
            
            index += 1; 

        }
        
    }

    mes

}

pub fn run(inp: Vec<String>) {
    const DECRIPTION_KEY :i64 = 811589153; 

    let parsed_inp: Vec<(i64, usize)> = inp
        .iter()
        .enumerate()
        .map(|elem| (elem.1.parse::<i64>().unwrap() * DECRIPTION_KEY, elem.0))
        .collect();


    let decripted_message = decript_message(parsed_inp);

    println!("{:?}", decripted_message); 


    // find index of 0: 
    for (i, e) in decripted_message.iter().enumerate() {
        if e.0 == 0 {
            let a = decripted_message[(i + 1000) % decripted_message.len()].0; 
            let b = decripted_message[(i + 2000) % decripted_message.len()].0; 
            let c = decripted_message[(i + 3000) % decripted_message.len()].0; 

            println!("a:{}; b:{}, c:{}", a, b, c); 
            
            println!("a2: {}", a + b + c); 
        }
    }

}