Progress :)

hw8/task1/src/main.rs

     let diff = Arc::new(matches.value_of("difficulty").unwrap_or("1").to_string());
     let cpus = sys_info::cpu_num().unwrap_or(1).to_string();
     let threads = matches.value_of("threads").unwrap_or(&cpus);
+    let sync = matches.is_present("sync");
+    let verbosity = matches.occurrences_of("verbose"); 
+    
     let mut time_measurement = false;
+    let mut found = false;
 
     if diff.chars().any(|c| !c.is_digit(16)) {
         println!("Difficulty is not hexadecimal.");
         }
     }
 
-    if true {
+    if verbosity >= 1 {
         println!("--------------------------------------------");
         println!("Container: \"{}\"", sys_info::hostname().unwrap_or("-".to_string()));
         println!("Physical CPUs : {}", sys_info::cpu_num().unwrap_or(0));
 
     match (base.parse::<usize>(), threads.parse::<usize>()) {
         (Ok(b), Ok(t)) => {
-            println!("Using base: {}", b);
-            println!("Using difficulty: {}", diff);
             println!("Please wait...");
+
+            if verbosity >= 1 {
+                println!("Searching with {} threads", t);
+            }
+
             let start = get_time();
             let max = <usize>::max_value();
             let mut children = vec![];
                 children.push(thread::spawn(move || {
                     let mut n = i;
                     while n < max {
-                        if n < 20 {
-                            println!("Thread {}: {}", i, n);
+
+                        if found && sync {
+                            process::exit(0);
                         }
-                        
-                        if let Some(x) = verify_product(b, n, &d) {
+
+                        if let Some(solution) = verify_product(b, n, &d) {
                             let end = get_time();
-                            println!("Number: {} --> hash: {}", x.number, x.hash);
+                            found = sync;
+                            
                             if time_measurement {
                                 let diff = end - start;
                                 let s = diff.num_seconds();
                                 let us = diff.num_microseconds().unwrap_or(ms * 1000);
                                 println!("(Duration {}s / {}ms / {}us)", s, ms, us);
                             }
-                            tx.send("Finished").unwrap();
+                            tx.send(solution).unwrap();
                         }
                         n += t;
                     }
             }
 
             match rx.recv() {
-                Ok(msg) => {
-                    println!("{}", msg);
+                Ok(sol) => {
+                    println!("Number: {} --> hash: {}", sol.number, sol.hash);
                 }
                 Err(_) => {}
             }
-            /*
-            for child in children {
-                let _ = child.join();
-            } 
-            */
         }
         (_, Err(_)) => {
             println!("Number of threads is not integer.");
         .arg(
             Arg::with_name("base")
                 .value_name("base")
-                .help("The base of the hash to be calculated on.")
+                .help("Sets the base to use")
                 .takes_value(true)
                 .required(true),
         )
         .arg(
             Arg::with_name("difficulty")
                 .value_name("difficulty")
-                .help("The difficulty of the calculated hash.")
+                .help("Sets the difficulty to use")
                 .takes_value(true)
                 .required(true),
         )
                 )
                 .takes_value(true)
                 .required(false),
+        ).arg(Arg::with_name("verbose")
+              .short("v")
+              .multiple(true)
+              .required(false),
         )
-	.arg(Arg::with_name("verbose")
-       		.short("v")
-        	.multiple(true)
-        )
-	.subcommand(
+    .arg(Arg::with_name("sync")
+            .short("s")
+            .required(false),
+    )
+    .arg(Arg::with_name("config")
+            .long("config")
+            .value_name("VALUE")
+            .help("sets special sync parameter")
+                               .takes_value(true))
+    .subcommand(
             SubCommand::with_name("timings")
                 .about("controls timing features")
                 .version("1.0")