diff --git a/src/euler31/src/main.rs b/src/euler31/src/main.rs
index c8d17ce..3a2fe69 100644
--- a/src/euler31/src/main.rs
+++ b/src/euler31/src/main.rs
@@ -30,31 +30,56 @@ impl Node {
         }
     }
 
+    fn get_value(&self, index: usize) -> Option<&u8> {
+        self.values.get(index)
+    }
+
     fn iter(&mut self) {
         if !self.nodes.is_empty() {
             self.nodes.iter_mut().for_each(|n| n.iter())
         } else {
             let mut previous: Option<Values> = None;
+            let mut offset = 0;
             for (i, value) in self.values.iter().enumerate() {
-                let j = i * 2;
-                let half = value / 2;
-                let mut new_vec;
-                if let Some(inner) = previous {
-                    new_vec = inner.clone();
-                } else {
-                    new_vec = self.values.clone();
-                };
+                let divided = divide_value(*value);
+                println!();
+                println!();
+                println!();
+                for combination in divided {
+                    let mut new_vec;
+                    if let Some(inner) = previous {
+                        new_vec = inner.clone();
+                    } else {
+                        new_vec = self.values.clone();
+                    };
+                    println!();
+                    println!("{}", i + offset);
+                    println!("{new_vec:#?}");
+                    println!("{combination:#?}");
 
-                new_vec[j] = half;
-                new_vec.insert(j, half);
-                previous = Some(new_vec.clone());
-                debug_assert_eq!(new_vec.iter().sum::<u8>(), VALUE);
-                self.nodes.push(Node::new_vec(new_vec));
+                    new_vec.splice(i + offset..i + offset + 1, combination.clone());
+                    println!("{new_vec:#?}");
+                    previous = Some(new_vec.clone());
+                    debug_assert_eq!(new_vec.iter().sum::<u8>(), VALUE);
+                    self.nodes.push(Node::new_vec(new_vec));
+                    offset += combination.len() - 1;
+                }
             }
         }
     }
 }
 
+fn divide_value(x: u8) -> Vec<Values> {
+    if x == 200 {
+        vec![vec![100, 100]]
+    } else if x == 100 {
+        vec![vec![50, 50]]
+    } else {
+        // x == 50
+        vec![vec![20, 20, 10], vec![20, 10, 10, 10], vec![10; 5]]
+    }
+}
+
 impl Index<usize> for Node {
     type Output = Node;
 
@@ -90,5 +115,15 @@ mod test {
         tree.iter();
         assert_eq!(tree.nodes[0][0].values, vec![50, 50, 100]);
         assert_eq!(tree.nodes[0][1].values, vec![50; 4]);
+        assert!(tree.nodes[0].get_value(2).is_none());
+    }
+
+    #[test]
+    fn test_iter_3() {
+        let mut tree = Node::new(200);
+        tree.iter();
+        tree.iter();
+        tree.iter();
+        assert_eq!(tree.nodes[0][0][0].values, vec![20, 20, 10, 50, 100]);
     }
 }