diff --git a/Cargo.lock b/Cargo.lock
index e8b25e1..170c546 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -42,6 +42,13 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "lottery"
+version = "1.0.0"
+dependencies = [
+ "pyo3",
+]
+
 [[package]]
 name = "memoffset"
 version = "0.9.0"
@@ -80,13 +87,6 @@ dependencies = [
  "windows-targets",
 ]
 
-[[package]]
-name = "pls"
-version = "0.1.0"
-dependencies = [
- "pyo3",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.78"
diff --git a/Cargo.toml b/Cargo.toml
index dc4dea1..362d674 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
-name = "pls"
-version = "0.1.0"
+name = "lottery"
+version = "1.0.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
-name = "pls"
+name = "lottery"
 crate-type = ["cdylib"]
 
 [dependencies]
diff --git a/src/lib.rs b/src/lib.rs
index 810094d..6649d1a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,139 +1,10 @@
-use std::collections::{HashMap, HashSet};
+mod pls;
 
 use pyo3::prelude::*;
 
-/// Formats the sum of two numbers as string.
-#[pyfunction]
-fn get_numbers_by_sum(sum : u32, group_type: Option<u32>) -> PyResult<Vec<String>> {
-    let mut list: Vec<String> = Vec::new();
-    for i in 0..1000 {
-        let s = format!("{:03}", i);
-        match group_type {
-            Some(g) => {
-                let set :HashSet<char> = HashSet::from_iter(s.chars().into_iter());
-                if g == 1 && set.len() == 1 {
-                    list.push(s);
-                }else if g == 3 && set.len() == 2 {
-                    list.push(s);
-                } else if g == 6 && set.len() == 3 {
-                    list.push(s);
-                }
-            },
-            None => {
-                list.push(s);
-            }
-        }
-    }
-    let mut m : HashMap<u32, HashSet<String>> = HashMap::new();
-    for i in &list {
-        let nums: Vec<u32> = i.chars().map(|c| c.to_digit(10).unwrap()).collect();
-        let total: u32 = nums.iter().sum();
-        // println!("{:?}", total);
-        let mut chars = i.chars().collect::<Vec<_>>();
-        chars.sort_by(|a, b| a.cmp(b));
-
-        let s: String = chars.into_iter().collect();
-        // println!("{}", s);
-        let v = m.get(&total);
-        match v {
-            Some(v) => {
-                let mut v = v.clone();
-                v.insert(s);
-                m.insert(total, v);
-            },
-            None => {
-                let mut v = HashSet::new();
-                v.insert(s);
-                m.insert(total, v);
-            }
-        }
-    }
-    // println!("{:?}", m);
-    let mut result = Vec::new();
-    let values = m.get(&sum);
-    match values {
-        Some(values) => {
-            for i in values.into_iter() {
-                result.push(i.clone());
-            }
-        },
-        None => (),
-    }
-
-    result.sort_by(|x, y| x.cmp(y));
-
-    Ok(result)
-
-}
-
-#[pyfunction]
-fn get_numbers_by_span(span: u32, group_type: Option<u32>) -> PyResult<Vec<String>> {
-    let mut list: Vec<String> = Vec::new();
-    for i in 0..1000 {
-        let s = format!("{:03}", i);
-        match group_type {
-            Some(g) => {
-                let set :HashSet<char> = HashSet::from_iter(s.chars().into_iter());
-                if g == 1 && set.len() == 1 {
-                    list.push(s);
-                }else if g == 3 && set.len() == 2 {
-                    list.push(s);
-                } else if g == 6 && set.len() == 3 {
-                    list.push(s);
-                }
-            },
-            None => {
-                list.push(s);
-            }
-        }
-        
-    }
-    let mut m : HashMap<u32, HashSet<String>> = HashMap::new();
-    for i in &list {
-        let nums: Vec<u32> = i.chars().map(|c| c.to_digit(10).unwrap()).collect();
-        let diff = nums.iter().max().unwrap() - nums.iter().min().unwrap();
-
-        let mut chars = i.chars().collect::<Vec<_>>();
-        chars.sort_by(|a, b| a.cmp(b));
-
-        let s: String = chars.into_iter().collect();
-        
-
-        let v = m.get(&diff);
-        match v {
-            Some(v) => {
-                let mut v = v.clone();
-                v.insert(s);
-                m.insert(diff, v);
-            },
-            None => {
-                let mut v = HashSet::new();
-                v.insert(s);
-                m.insert(diff, v);
-            }
-        }
-
-    }
-    let mut result: Vec<String> = Vec::new();
-    let values = m.get(&span);
-    match values {
-        Some(values) => {
-            for i in values.into_iter() {
-                result.push(i.clone());
-            }
-        },
-        None => (),
-    }
-
-    result.sort_by(|x, y| x.cmp(y));
-
-    Ok(result)
-}
-
 /// A Python module implemented in Rust.
 #[pymodule]
-fn pls(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(get_numbers_by_sum, m)?)?;
-    m.add_function(wrap_pyfunction!(get_numbers_by_span, m)?)?;
+fn lottery(py: Python, m: &PyModule) -> PyResult<()> {
+    pls::register_pls_mod(py, m)?;
     Ok(())
 }
diff --git a/src/pls/mod.rs b/src/pls/mod.rs
new file mode 100644
index 0000000..f2d6a65
--- /dev/null
+++ b/src/pls/mod.rs
@@ -0,0 +1,140 @@
+use std::collections::{HashMap, HashSet};
+
+use pyo3::prelude::*;
+
+/// Formats the sum of two numbers as string.
+#[pyfunction]
+pub fn get_numbers_by_sum(sum : u32, group_type: Option<u32>) -> PyResult<Vec<String>> {
+    let mut list: Vec<String> = Vec::new();
+    for i in 0..1000 {
+        let s = format!("{:03}", i);
+        match group_type {
+            Some(g) => {
+                let set :HashSet<char> = HashSet::from_iter(s.chars().into_iter());
+                if g == 1 && set.len() == 1 {
+                    list.push(s);
+                }else if g == 3 && set.len() == 2 {
+                    list.push(s);
+                } else if g == 6 && set.len() == 3 {
+                    list.push(s);
+                }
+            },
+            None => {
+                list.push(s);
+            }
+        }
+    }
+    let mut m : HashMap<u32, HashSet<String>> = HashMap::new();
+    for i in &list {
+        let nums: Vec<u32> = i.chars().map(|c| c.to_digit(10).unwrap()).collect();
+        let total: u32 = nums.iter().sum();
+        // println!("{:?}", total);
+        let mut chars = i.chars().collect::<Vec<_>>();
+        chars.sort_by(|a, b| a.cmp(b));
+
+        let s: String = chars.into_iter().collect();
+        // println!("{}", s);
+        let v = m.get(&total);
+        match v {
+            Some(v) => {
+                let mut v = v.clone();
+                v.insert(s);
+                m.insert(total, v);
+            },
+            None => {
+                let mut v = HashSet::new();
+                v.insert(s);
+                m.insert(total, v);
+            }
+        }
+    }
+    // println!("{:?}", m);
+    let mut result = Vec::new();
+    let values = m.get(&sum);
+    match values {
+        Some(values) => {
+            for i in values.into_iter() {
+                result.push(i.clone());
+            }
+        },
+        None => (),
+    }
+
+    result.sort_by(|x, y| x.cmp(y));
+
+    Ok(result)
+
+}
+
+#[pyfunction]
+pub fn get_numbers_by_span(span: u32, group_type: Option<u32>) -> PyResult<Vec<String>> {
+    let mut list: Vec<String> = Vec::new();
+    for i in 0..1000 {
+        let s = format!("{:03}", i);
+        match group_type {
+            Some(g) => {
+                let set :HashSet<char> = HashSet::from_iter(s.chars().into_iter());
+                if g == 1 && set.len() == 1 {
+                    list.push(s);
+                }else if g == 3 && set.len() == 2 {
+                    list.push(s);
+                } else if g == 6 && set.len() == 3 {
+                    list.push(s);
+                }
+            },
+            None => {
+                list.push(s);
+            }
+        }
+        
+    }
+    let mut m : HashMap<u32, HashSet<String>> = HashMap::new();
+    for i in &list {
+        let nums: Vec<u32> = i.chars().map(|c| c.to_digit(10).unwrap()).collect();
+        let diff = nums.iter().max().unwrap() - nums.iter().min().unwrap();
+
+        let mut chars = i.chars().collect::<Vec<_>>();
+        chars.sort_by(|a, b| a.cmp(b));
+
+        let s: String = chars.into_iter().collect();
+        
+
+        let v = m.get(&diff);
+        match v {
+            Some(v) => {
+                let mut v = v.clone();
+                v.insert(s);
+                m.insert(diff, v);
+            },
+            None => {
+                let mut v = HashSet::new();
+                v.insert(s);
+                m.insert(diff, v);
+            }
+        }
+
+    }
+    let mut result: Vec<String> = Vec::new();
+    let values = m.get(&span);
+    match values {
+        Some(values) => {
+            for i in values.into_iter() {
+                result.push(i.clone());
+            }
+        },
+        None => (),
+    }
+
+    result.sort_by(|x, y| x.cmp(y));
+
+    Ok(result)
+}
+
+pub fn register_pls_mod(py: Python <'_>, parent_mod: &PyModule) -> PyResult<()> {
+    let child_mod = PyModule::new(py, "pls")?;
+    child_mod.add_function(wrap_pyfunction!(get_numbers_by_span, child_mod)?)?;
+    child_mod.add_function(wrap_pyfunction!(get_numbers_by_sum, child_mod)?)?;
+    parent_mod.add_submodule(child_mod)?;
+
+    Ok(())
+}
\ No newline at end of file