diff --git a/src/main.rs b/src/main.rs
index adda88b..25961a3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,32 +18,23 @@ use std::time::{Duration, Instant};
 
 
 trait Peristance {
-    fn per_mul(&self) -> u8;
-}
-
-trait MyProduct<A = Self> {
-    fn product<I: Iterator<Item=A>>(iter: I) -> Self;
-}
-
-impl MyProduct<Int> for Int {
-    fn product<I: Iterator<Item=Self>>(iter: I) -> Int {
-        iter.fold(Int::one(), <ramp::Int as Trait>::Mul)
-    }
+    fn per_mul(&self) -> i32;
 }
 
 
 impl Peristance for Int {
-    fn per_mul(&self) -> u8 {
+    fn per_mul(&self) -> i32 {
         let mut n = self.to_str_radix(10, false)
             .chars()
-            .map(|x| x - 48).collect()
-            .product::<Int>();
+            .map(|x| x as i32 - 48)
+            .fold(Int::one(), |acc, x| acc * x);
+            
         let mut counter = 1;
         while n.to_str_radix(10, false).chars().count() > 1 {
             n = n.to_str_radix(10, false)
                 .chars()
-                .map(|x| x - 48).collect()
-                .product::<Int>();
+                .map(|x| x as i32 - 48)
+                .fold(Int::one(), |acc, x| acc * x);
             counter += 1;
         }
         return counter;
@@ -54,12 +45,12 @@ impl Peristance for Int {
 #[derive(Debug)]
 struct Counter {
     count: Int,
-    step: u8,
-    offset: u8
+    step: i32,
+    offset: i32
 }
 
 impl Counter {
-    fn new(_step: u8, _offset: u8) -> Counter {
+    fn new(_step: i32, _offset: i32) -> Counter {
         Counter {count: Int::zero(), step: _step, offset: _offset}
     }
 }
@@ -87,13 +78,13 @@ fn main() {
         .get_matches();
 
 
-    let mut cpus = value_t!(args, "jobs", u8).unwrap_or(num_cpus::get() as u8);
+    let mut cpus = value_t!(args, "jobs", i32).unwrap_or(num_cpus::get() as i32);
     if cpus == 0 {
-        cpus = num_cpus::get() as u8;
+        cpus = num_cpus::get() as i32;
     }
     let cpus = cpus;
 
-    let max = value_t!(args, "max", u8).unwrap_or(11u8);
+    let max: i32 = value_t!(args, "max", i32).unwrap_or(11i32);
 
     println!("threads: {}", cpus);
 
@@ -103,7 +94,7 @@ fn main() {
         thread::spawn(move || {
             println!("Started thread {}!", thread);
             let counter =  Counter::new(cpus-thread, cpus);
-            let mut top: u8 = 0;
+            let mut top: i32 = 0;
             for x in counter {
                 let n = x.per_mul();
                 if n > top {