diff --git a/src/peripherals/genesis/ym7101.rs b/src/peripherals/genesis/ym7101.rs
index f35423f..66e9a03 100644
--- a/src/peripherals/genesis/ym7101.rs
+++ b/src/peripherals/genesis/ym7101.rs
@@ -561,173 +561,6 @@ impl Ym7101State {
             }
         }
     }
-
-    /*
-    pub fn get_pattern_iter<'a>(&'a self, pattern_name: u16, line: i8) -> PatternIterator<'a> {
-        let pattern_addr = (pattern_name & 0x07FF) << 5;
-        let pattern_palette = ((pattern_name & 0x6000) >> 13) as u8;
-        let h_rev = (pattern_name & 0x0800) != 0;
-        let v_rev = (pattern_name & 0x1000) != 0;
-        let mode = if (pattern_name & 0x8000) != 0 { ColourMode::Shadow } else { ColourMode::Normal };
-        PatternIterator::new(&self, pattern_addr as u32, pattern_palette, mode, h_rev, v_rev, line)
-    }
-
-    pub fn get_scroll_a_pattern(&self, cell_x: usize, cell_y: usize, hscrolling_a: usize, vscrolling_a: usize) -> u16 {
-        let pattern_x = ((cell_x + self.window_offset.0) as usize - (hscrolling_a / 8) as usize) % self.scroll_size.0 as usize;
-        let pattern_y = ((cell_y + self.window_offset.1) as usize + (vscrolling_a / 8) as usize) % self.scroll_size.1 as usize;
-        let pattern_addr = self.get_pattern_addr(self.scroll_a_addr, pattern_x, pattern_y);
-        self.memory.read_beu16(Memory::Vram, pattern_addr)
-    }
-
-    pub fn get_scroll_b_pattern(&self, cell_x: usize, cell_y: usize, hscrolling_b: usize, vscrolling_b: usize) -> u16 {
-        let pattern_x = ((cell_x + self.window_offset.0) as usize - (hscrolling_b / 8) as usize) % self.scroll_size.0 as usize;
-        let pattern_y = ((cell_y + self.window_offset.1) as usize + (vscrolling_b / 8) as usize) % self.scroll_size.1 as usize;
-        let pattern_addr = self.get_pattern_addr(self.scroll_b_addr, pattern_x, pattern_y);
-        self.memory.read_beu16(Memory::Vram, pattern_addr)
-    }
-
-
-    pub fn draw_pattern(&mut self, frame: &mut Frame, pattern: u16, pixel_x: u32, pixel_y: u32) {
-        let iter = self.get_pattern_iter(pattern, 0);
-        frame.blit(pixel_x, pixel_y, iter, 8, 8);
-    }
-
-    pub fn draw_pattern_line(&mut self, frame: &mut Frame, pattern: u16, pixel_x: u32, pixel_y: u32, line: i8) {
-        let iter = self.get_pattern_iter(pattern, line);
-        frame.blit(pixel_x, pixel_y, iter, 8, 1);
-    }
-
-
-
-    pub fn draw_frame_old(&mut self, frame: &mut Frame) {
-        self.draw_background(frame);
-        self.draw_scrolls(frame);
-        //self.draw_window(frame);
-        self.draw_sprites(frame);
-    }
-
-    pub fn draw_background(&mut self, frame: &mut Frame) {
-        let bg_colour = self.get_palette_colour((self.background & 0x30) >> 4, self.background & 0x0f, ColourMode::Normal);
-        frame.clear(bg_colour);
-    }
-
-    #[inline(always)]
-    pub fn draw_scrolls(&mut self, frame: &mut Frame) {
-        if (self.mode_3 & MODE3_BF_H_SCROLL_MODE) != 3 {
-            self.draw_scrolls_cell(frame);
-        } else {
-            self.draw_scrolls_line(frame);
-        }
-    }
-
-    pub fn draw_scrolls_cell(&mut self, frame: &mut Frame) {
-        let (cells_h, cells_v) = self.screen_size;
-
-        for cell_y in 0..cells_v {
-            let (hscrolling_a, hscrolling_b) = self.get_hscroll(cell_y, 0);
-            for cell_x in 0..cells_h {
-                let (vscrolling_a, vscrolling_b) = self.get_vscroll(cell_x);
-
-                let pattern_b = self.get_scroll_b_pattern(cell_x, cell_y, hscrolling_b, vscrolling_b);
-                let pattern_a = self.get_scroll_a_pattern(cell_x, cell_y, hscrolling_a, vscrolling_a);
-
-                //if (pattern_b & 0x8000) != 0 && (pattern_a & 0x8000) == 0 {
-                self.draw_pattern(frame, pattern_b, (cell_x << 3) as u32, (cell_y << 3) as u32 - (vscrolling_b as u32 % 8));
-                self.draw_pattern(frame, pattern_a, (cell_x << 3) as u32, (cell_y << 3) as u32 - (vscrolling_b as u32 % 8));
-            }
-        }
-    }
-
-    pub fn draw_scrolls_line(&mut self, frame: &mut Frame) {
-        let (cells_h, cells_v) = self.screen_size;
-
-        for cell_y in 0..cells_v {
-            for line in 0..8 {
-                let (hscrolling_a, hscrolling_b) = self.get_hscroll(cell_y, line as usize);
-                for cell_x in 0..cells_h {
-                    let (_, vscrolling_b) = self.get_vscroll(cell_x);
-
-                    let pattern_b = self.get_scroll_b_pattern(cell_x, cell_y, hscrolling_b, vscrolling_b);
-                    self.draw_pattern_line(frame, pattern_b, (cell_x << 3) as u32 + (hscrolling_b as u32 % 8), (cell_y << 3) as u32 + line as u32 - (vscrolling_b as u32 % 8), line);
-                }
-
-                for cell_x in 0..cells_h {
-                    let (vscrolling_a, _) = self.get_vscroll(cell_x);
-
-                    let pattern_a = self.get_scroll_a_pattern(cell_x, cell_y, hscrolling_a, vscrolling_a);
-                    self.draw_pattern_line(frame, pattern_a, (cell_x << 3) as u32 + (hscrolling_a as u32 % 8), (cell_y << 3) as u32 + line as u32 - (vscrolling_a as u32 % 8), line);
-                }
-            }
-        }
-    }
-
-    pub fn draw_window(&mut self, frame: &mut Frame) {
-        let cell_table = self.window_addr;
-        let (cells_h, cells_v) = self.screen_size;
-
-        // A window address of 0 disables the window
-        if cell_table == 0 {
-            return;
-        }
-
-        for cell_y in 0..cells_v {
-            for cell_x in 0..cells_h {
-                let pattern_w = self.memory.read_beu16(Memory::Vram, self.get_pattern_addr(cell_table, cell_x as usize, cell_y as usize));
-                if pattern_w != 0 {
-                    self.draw_pattern(frame, pattern_w, (cell_x << 3) as u32, (cell_y << 3) as u32);
-                }
-            }
-        }
-    }
-
-    pub fn build_link_list(&mut self, sprite_table: usize, links: &mut [usize]) -> usize {
-        links[0] = 0;
-        let mut i = 0;
-        loop {
-            let link = self.memory.read_u8(Memory::Vram, sprite_table + (links[i] * 8) + 3);
-            if link == 0 || link >= 80 {
-                break;
-            }
-            i += 1;
-            links[i] = link as usize;
-        }
-        i
-    }
-
-    pub fn draw_sprites(&mut self, frame: &mut Frame) {
-        let sprite_table = self.sprites_addr;
-        let (cells_h, cells_v) = self.screen_size;
-        let (pos_limit_h, pos_limit_v) = (if cells_h == 32 { 383 } else { 447 }, if cells_v == 28 { 351 } else { 367 });
-
-        let mut links = [0; 80];
-        let lowest = self.build_link_list(sprite_table, &mut links);
-
-        for i in (0..lowest + 1).rev() {
-            let sprite_data = &self.memory.vram[(sprite_table + (links[i] * 8))..];
-
-            let v_pos = read_beu16(&sprite_data[0..]);
-            let size = sprite_data[2];
-            let pattern_name = read_beu16(&sprite_data[4..]);
-            let h_pos = read_beu16(&sprite_data[6..]);
-
-            let (size_h, size_v) = (((size >> 2) & 0x03) as u16 + 1, (size & 0x03) as u16 + 1);
-            let h_rev = (pattern_name & 0x0800) != 0;
-            let v_rev = (pattern_name & 0x1000) != 0;
-
-            for ih in 0..size_h {
-                for iv in 0..size_v {
-                    let (h, v) = (if !h_rev { ih } else { size_h - 1 - ih }, if !v_rev { iv } else { size_v - 1 - iv });
-                    let (x, y) = (h_pos + ih * 8, v_pos + iv * 8);
-                    if x > 128 && x < pos_limit_h && y > 128 && y < pos_limit_v {
-                        let iter = self.get_pattern_iter(((pattern_name & 0x07FF) + (h * size_v) + v) | (pattern_name & 0xF800), 0);
-
-                        frame.blit(x as u32 - 128, y as u32 - 128, iter, 8, 8);
-                    }
-                }
-            }
-        }
-    }
-    */
 }
 
 pub struct Sprite {
@@ -766,63 +599,6 @@ impl Sprite {
 }
 
 
-/*
-pub struct PatternIterator<'a> {
-    state: &'a Ym7101State,
-    palette: u8,
-    mode: ColourMode,
-    base: usize,
-    h_rev: bool,
-    v_rev: bool,
-    line: i8,
-    col: i8,
-    second: bool,
-}
-
-impl<'a> PatternIterator<'a> {
-    pub fn new(state: &'a Ym7101State, start: u32, palette: u8, mode: ColourMode, h_rev: bool, v_rev: bool, line: i8) -> Self {
-        Self {
-            state,
-            palette,
-            mode,
-            base: start as usize,
-            h_rev,
-            v_rev,
-            line,
-            col: 0,
-            second: false,
-        }
-    }
-}
-
-impl<'a> Iterator for PatternIterator<'a> {
-    type Item = u32;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let offset = self.base + (if !self.v_rev { self.line } else { 7 - self.line }) as usize * 4 + (if !self.h_rev { self.col } else { 3 - self.col }) as usize;
-        let value = if (!self.h_rev && !self.second) || (self.h_rev && self.second) {
-            self.state.get_palette_colour(self.palette, self.state.memory.vram[offset] >> 4, self.mode)
-        } else {
-            self.state.get_palette_colour(self.palette, self.state.memory.vram[offset] & 0x0f, self.mode)
-        };
-
-        if !self.second {
-            self.second = true;
-        } else {
-            self.second = false;
-            self.col += 1;
-            if self.col >= 4 {
-                self.col = 0;
-                self.line += 1;
-            }
-        }
-
-        Some(value)
-    }
-}
-*/
-
-
 pub struct Ym7101 {
     swapper: FrameSwapper,
     state: Ym7101State,