diff --git a/src/structures/paging/mapper/mapped_page_table.rs b/src/structures/paging/mapper/mapped_page_table.rs
index b3cfa0ff..5f673c55 100644
--- a/src/structures/paging/mapper/mapped_page_table.rs
+++ b/src/structures/paging/mapper/mapped_page_table.rs
@@ -49,10 +49,11 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
     pub fn page_table_frame_mapping(&self) -> &P {
         &self.page_table_walker.page_table_frame_mapping
     }
+}
 
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_1gib<A>(
+impl<P: PageTableFrameMapping> Mapper<Size1GiB> for MappedPageTable<'_, P> {
+    #[inline]
+    unsafe fn map_to_with_table_flags<A>(
         &mut self,
         page: Page<Size1GiB>,
         frame: PhysFrame<Size1GiB>,
@@ -78,94 +79,6 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
         Ok(MapperFlush::new(page))
     }
 
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_2mib<A>(
-        &mut self,
-        page: Page<Size2MiB>,
-        frame: PhysFrame<Size2MiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        let p4 = &mut self.level_4_table;
-        let p3 = self.page_table_walker.create_next_table(
-            &mut p4[page.p4_index()],
-            parent_table_flags,
-            allocator,
-        )?;
-        let p2 = self.page_table_walker.create_next_table(
-            &mut p3[page.p3_index()],
-            parent_table_flags,
-            allocator,
-        )?;
-
-        if !p2[page.p2_index()].is_unused() {
-            return Err(MapToError::PageAlreadyMapped(frame));
-        }
-        p2[page.p2_index()].set_addr(frame.start_address(), flags | PageTableFlags::HUGE_PAGE);
-
-        Ok(MapperFlush::new(page))
-    }
-
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_4kib<A>(
-        &mut self,
-        page: Page<Size4KiB>,
-        frame: PhysFrame<Size4KiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        let p4 = &mut self.level_4_table;
-        let p3 = self.page_table_walker.create_next_table(
-            &mut p4[page.p4_index()],
-            parent_table_flags,
-            allocator,
-        )?;
-        let p2 = self.page_table_walker.create_next_table(
-            &mut p3[page.p3_index()],
-            parent_table_flags,
-            allocator,
-        )?;
-        let p1 = self.page_table_walker.create_next_table(
-            &mut p2[page.p2_index()],
-            parent_table_flags,
-            allocator,
-        )?;
-
-        if !p1[page.p1_index()].is_unused() {
-            return Err(MapToError::PageAlreadyMapped(frame));
-        }
-        p1[page.p1_index()].set_frame(frame, flags);
-
-        Ok(MapperFlush::new(page))
-    }
-}
-
-impl<P: PageTableFrameMapping> Mapper<Size1GiB> for MappedPageTable<'_, P> {
-    #[inline]
-    unsafe fn map_to_with_table_flags<A>(
-        &mut self,
-        page: Page<Size1GiB>,
-        frame: PhysFrame<Size1GiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        self.map_to_1gib(page, frame, flags, parent_table_flags, allocator)
-    }
-
     fn unmap(
         &mut self,
         page: Page<Size1GiB>,
@@ -271,7 +184,24 @@ impl<P: PageTableFrameMapping> Mapper<Size2MiB> for MappedPageTable<'_, P> {
     where
         A: FrameAllocator<Size4KiB> + ?Sized,
     {
-        self.map_to_2mib(page, frame, flags, parent_table_flags, allocator)
+        let p4 = &mut self.level_4_table;
+        let p3 = self.page_table_walker.create_next_table(
+            &mut p4[page.p4_index()],
+            parent_table_flags,
+            allocator,
+        )?;
+        let p2 = self.page_table_walker.create_next_table(
+            &mut p3[page.p3_index()],
+            parent_table_flags,
+            allocator,
+        )?;
+
+        if !p2[page.p2_index()].is_unused() {
+            return Err(MapToError::PageAlreadyMapped(frame));
+        }
+        p2[page.p2_index()].set_addr(frame.start_address(), flags | PageTableFlags::HUGE_PAGE);
+
+        Ok(MapperFlush::new(page))
     }
 
     fn unmap(
@@ -399,7 +329,29 @@ impl<P: PageTableFrameMapping> Mapper<Size4KiB> for MappedPageTable<'_, P> {
     where
         A: FrameAllocator<Size4KiB> + ?Sized,
     {
-        self.map_to_4kib(page, frame, flags, parent_table_flags, allocator)
+        let p4 = &mut self.level_4_table;
+        let p3 = self.page_table_walker.create_next_table(
+            &mut p4[page.p4_index()],
+            parent_table_flags,
+            allocator,
+        )?;
+        let p2 = self.page_table_walker.create_next_table(
+            &mut p3[page.p3_index()],
+            parent_table_flags,
+            allocator,
+        )?;
+        let p1 = self.page_table_walker.create_next_table(
+            &mut p2[page.p2_index()],
+            parent_table_flags,
+            allocator,
+        )?;
+
+        if !p1[page.p1_index()].is_unused() {
+            return Err(MapToError::PageAlreadyMapped(frame));
+        }
+        p1[page.p1_index()].set_frame(frame, flags);
+
+        Ok(MapperFlush::new(page))
     }
 
     fn unmap(
diff --git a/src/structures/paging/mapper/recursive_page_table.rs b/src/structures/paging/mapper/recursive_page_table.rs
index ff427ffa..bd3c5981 100644
--- a/src/structures/paging/mapper/recursive_page_table.rs
+++ b/src/structures/paging/mapper/recursive_page_table.rs
@@ -166,10 +166,11 @@ impl<'a> RecursivePageTable<'a> {
 
         inner(entry, next_table_page, insert_flags, allocator)
     }
+}
 
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_1gib<A>(
+impl Mapper<Size1GiB> for RecursivePageTable<'_> {
+    #[inline]
+    unsafe fn map_to_with_table_flags<A>(
         &mut self,
         page: Page<Size1GiB>,
         frame: PhysFrame<Size1GiB>,
@@ -201,120 +202,6 @@ impl<'a> RecursivePageTable<'a> {
         Ok(MapperFlush::new(page))
     }
 
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_2mib<A>(
-        &mut self,
-        page: Page<Size2MiB>,
-        frame: PhysFrame<Size2MiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        use crate::structures::paging::PageTableFlags as Flags;
-        let p4 = &mut self.p4;
-
-        let p3_page = p3_page(page, self.recursive_index);
-        let p3 = unsafe {
-            Self::create_next_table(
-                &mut p4[page.p4_index()],
-                p3_page,
-                parent_table_flags,
-                allocator,
-            )?
-        };
-
-        let p2_page = p2_page(page, self.recursive_index);
-        let p2 = unsafe {
-            Self::create_next_table(
-                &mut p3[page.p3_index()],
-                p2_page,
-                parent_table_flags,
-                allocator,
-            )?
-        };
-
-        if !p2[page.p2_index()].is_unused() {
-            return Err(MapToError::PageAlreadyMapped(frame));
-        }
-        p2[page.p2_index()].set_addr(frame.start_address(), flags | Flags::HUGE_PAGE);
-
-        Ok(MapperFlush::new(page))
-    }
-
-    /// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
-    /// https://github.com/rust-lang/rfcs/pull/2585.
-    fn map_to_4kib<A>(
-        &mut self,
-        page: Page<Size4KiB>,
-        frame: PhysFrame<Size4KiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        let p4 = &mut self.p4;
-
-        let p3_page = p3_page(page, self.recursive_index);
-        let p3 = unsafe {
-            Self::create_next_table(
-                &mut p4[page.p4_index()],
-                p3_page,
-                parent_table_flags,
-                allocator,
-            )?
-        };
-
-        let p2_page = p2_page(page, self.recursive_index);
-        let p2 = unsafe {
-            Self::create_next_table(
-                &mut p3[page.p3_index()],
-                p2_page,
-                parent_table_flags,
-                allocator,
-            )?
-        };
-
-        let p1_page = p1_page(page, self.recursive_index);
-        let p1 = unsafe {
-            Self::create_next_table(
-                &mut p2[page.p2_index()],
-                p1_page,
-                parent_table_flags,
-                allocator,
-            )?
-        };
-
-        if !p1[page.p1_index()].is_unused() {
-            return Err(MapToError::PageAlreadyMapped(frame));
-        }
-        p1[page.p1_index()].set_frame(frame, flags);
-
-        Ok(MapperFlush::new(page))
-    }
-}
-
-impl Mapper<Size1GiB> for RecursivePageTable<'_> {
-    #[inline]
-    unsafe fn map_to_with_table_flags<A>(
-        &mut self,
-        page: Page<Size1GiB>,
-        frame: PhysFrame<Size1GiB>,
-        flags: PageTableFlags,
-        parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        self.map_to_1gib(page, frame, flags, parent_table_flags, allocator)
-    }
-
     fn unmap(
         &mut self,
         page: Page<Size1GiB>,
@@ -432,7 +319,35 @@ impl Mapper<Size2MiB> for RecursivePageTable<'_> {
     where
         A: FrameAllocator<Size4KiB> + ?Sized,
     {
-        self.map_to_2mib(page, frame, flags, parent_table_flags, allocator)
+        use crate::structures::paging::PageTableFlags as Flags;
+        let p4 = &mut self.p4;
+
+        let p3_page = p3_page(page, self.recursive_index);
+        let p3 = unsafe {
+            Self::create_next_table(
+                &mut p4[page.p4_index()],
+                p3_page,
+                parent_table_flags,
+                allocator,
+            )?
+        };
+
+        let p2_page = p2_page(page, self.recursive_index);
+        let p2 = unsafe {
+            Self::create_next_table(
+                &mut p3[page.p3_index()],
+                p2_page,
+                parent_table_flags,
+                allocator,
+            )?
+        };
+
+        if !p2[page.p2_index()].is_unused() {
+            return Err(MapToError::PageAlreadyMapped(frame));
+        }
+        p2[page.p2_index()].set_addr(frame.start_address(), flags | Flags::HUGE_PAGE);
+
+        Ok(MapperFlush::new(page))
     }
 
     fn unmap(
@@ -587,7 +502,44 @@ impl Mapper<Size4KiB> for RecursivePageTable<'_> {
     where
         A: FrameAllocator<Size4KiB> + ?Sized,
     {
-        self.map_to_4kib(page, frame, flags, parent_table_flags, allocator)
+        let p4 = &mut self.p4;
+
+        let p3_page = p3_page(page, self.recursive_index);
+        let p3 = unsafe {
+            Self::create_next_table(
+                &mut p4[page.p4_index()],
+                p3_page,
+                parent_table_flags,
+                allocator,
+            )?
+        };
+
+        let p2_page = p2_page(page, self.recursive_index);
+        let p2 = unsafe {
+            Self::create_next_table(
+                &mut p3[page.p3_index()],
+                p2_page,
+                parent_table_flags,
+                allocator,
+            )?
+        };
+
+        let p1_page = p1_page(page, self.recursive_index);
+        let p1 = unsafe {
+            Self::create_next_table(
+                &mut p2[page.p2_index()],
+                p1_page,
+                parent_table_flags,
+                allocator,
+            )?
+        };
+
+        if !p1[page.p1_index()].is_unused() {
+            return Err(MapToError::PageAlreadyMapped(frame));
+        }
+        p1[page.p1_index()].set_frame(frame, flags);
+
+        Ok(MapperFlush::new(page))
     }
 
     fn unmap(