badline 0.8.0 → 0.10.0

data/lib/badline/frontend/name_field.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's prompt for a name, typed with the keys by their
+    # place on a US keyboard: letters, with Shift for capitals, digits,
+    # space, - and _ and the full stop. Backspace deletes, Return takes the
+    # name and Esc leaves it.
+    class NameField
+      COLUMNS = 30
+      LETTERS = "abcdefghijklmnopqrstuvwxyz"
+      DIGITS = "1234567890"
+      OTHERS = { 44 => [" ", " "], 45 => ["-", "_"], 55 => [".", "."] }.freeze
+
+      RETURN = 40
+      ESCAPE = 41
+      BACKSPACE = 42
+
+      attr_reader :text
+
+      def initialize(painter)
+        @painter = painter
+        @open = false
+        @title = ""
+        @text = ""
+        @problem = ""
+      end
+
+      def open? = @open
+
+      def open(title, text)
+        @open = true
+        @title = title
+        @text = text
+        @problem = ""
+      end
+
+      def close
+        @open = false
+      end
+
+      # Says why the name won't do, under the field.
+      def refuse(problem)
+        @problem = problem
+      end
+
+      # Handles a key, and returns :done for Return, :cancel for Esc, or
+      # nil.
+      def key(scancode, shift)
+        return :done if scancode == RETURN
+        return :cancel if scancode == ESCAPE
+
+        @problem = ""
+        if scancode == BACKSPACE
+          @text = @text[0, @text.length - 1].to_s
+        else
+          char = character(scancode, shift)
+          @text += char unless char.empty? || @text.length >= COLUMNS
+        end
+        nil
+      end
+
+      def draw(left, top, width)
+        painter = @painter
+        painter.text(left, top, @title, PauseMenu::BRIGHT)
+        painter.box(left, top + 18, width, Buttons::HEIGHT + 4, PauseMenu::FILL)
+        painter.text(left + 4, top + 22, "#{@text}_", PauseMenu::TEXT)
+        painter.text(left, top + 42, @problem, MenuPages::WARNING) unless @problem.empty?
+        painter.text(left, top + 60, "RETURN: SAVE  ESC: CANCEL", PauseMenu::DIM)
+      end
+
+      private
+
+      def character(scancode, shift)
+        if scancode.between?(4, 29)
+          letter = LETTERS[scancode - 4]
+          shift ? letter.upcase : letter
+        elsif scancode.between?(30, 39)
+          DIGITS[scancode - 30]
+        elsif OTHERS.key?(scancode)
+          OTHERS[scancode][shift ? 1 : 0]
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/pacer.rb

@@ -13,7 +13,8 @@ module Badline
     # SAFETY, so no samples are dropped. #measure fits the frames to the
     # rate the display presents at, measured over the whole run.
     #
-    # Without vsync, a frame is one of the machine's frames, 20 ms on PAL.
+    # Without vsync, a frame is one of the machine's frames, as its Timing
+    # gives them, 20 ms on PAL.
     # With the sound playing, #wait lasts until the audio queue is down to
     # Sound::AHEAD; otherwise it waits out the rest of the frame.
     class Pacer
@@ -23,12 +24,12 @@ module Badline
 
       attr_reader :rate
 
-      def initialize(paced:, vsync:, verbose:, region: Region::PAL)
+      def initialize(paced:, vsync:, verbose:, timing:)
         @paced = paced
         @verbose = verbose
         @vsync = paced && vsync
-        @region = region
-        @rate = FrameRate.machine(region)
+        @timing = timing
+        @rate = FrameRate.machine(timing)
         @deadline = 0.0
         @measured_frames = 0
         @measured_seconds = 0.0
@@ -39,7 +40,7 @@ module Badline
       # Fits the frames to the display's refresh rate, once the window has
       # been opened with vsync.
       def fit(refresh)
-        @rate = FrameRate.display(refresh, @region.clock_hz)
+        @rate = FrameRate.display(refresh, @timing.clock_hz)
         puts "Display #{@rate.refresh} Hz, vsync: #{@rate.base_cycles} cycles a frame" if @verbose
       end
 

data/lib/badline/frontend/pause_menu.rb

@@ -14,9 +14,8 @@ module Badline
     # a cartridge going in or out ask first, as each power cycles the
     # machine.
     class PauseMenu
-      SECTIONS = ["DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
-      PAGES = %i[drive datasette expansion ports sound power].freeze
-      DISKS = %w[.d64 .d71 .d81 .g64 .t64].freeze
+      SECTIONS = ["SNAPSHOTS", "DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
+      PAGES = %i[snapshots drive datasette expansion ports sound power].freeze
 
       PANEL = 0x1d2230
       EDGE = 0x3a4256
@@ -25,40 +24,37 @@ module Badline
       DIM = 0x6b7489
       FILL = 0x343c50
 
-      LEFT = 16
-      TOP = 16
-      WIDTH = Screen::WIDTH - 32
-      HEIGHT = Screen::HEIGHT - 32
-      BODY = 154
+      MARGIN = 16
+      WIDTH = 352
+      HEIGHT = 240
+      BODY = 138
 
       ESCAPE = 41
       RETURN = 40
       SPACE = 44
+      SNAPSHOT_ACTIONS = %i[quicksave_now save_as load_save].freeze
       ARROWS = { 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       MOUSEWHEEL = 0x403
 
       # Takes the media, the REU and whether disks are writable from Options.
-      def initialize(painter, options)
+      def initialize(painter, options, snapshots)
         media_path = options.media_path.to_s
         @painter = painter
         @buttons = Buttons.new(painter, [TEXT, BRIGHT, PANEL, FILL])
-        @pages = MenuPages.new(painter, @buttons, PauseMenu.disk_path(media_path), options)
-        @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options)
+        @pages = MenuPages.new(painter, @buttons, media_path, options, snapshots)
+        @snapshots = snapshots
+        @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options, snapshots)
         @open = false
         @section = 0
-      end
-
-      # The path of the disk the command line puts in device 8, or an empty
-      # one for other media.
-      def self.disk_path(path)
-        return "" if path.empty?
-        return path if File.directory?(path)
-
-        DISKS.include?(File.extname(path).downcase) ? path : ""
+        @left = MARGIN
+        @top = MARGIN
       end
 
       def open? = @open
 
+      # The index in PAGES of the page #show opens on.
+      attr_writer :section
+
       # The machine Quick open started, which the app runs in place of the
       # one before once #frame returns :swap.
       def computer = @dialogs.computer
@@ -113,10 +109,10 @@ module Badline
       end
 
       # Handles the events that came in, draws the menu over the frozen
-      # picture, dimmed, and returns the action the app has to take on, if
-      # any, leaving the events after one for the machine. Key releases
-      # still reach the machine, so no key stays held down while it stands
-      # still.
+      # picture, dimmed, for the app to present, and returns the action the
+      # app has to take on, if any, leaving the events after one for the
+      # machine. Key releases still reach the machine, so no key stays held
+      # down while it stands still.
       def frame(renderer, texture, controls)
         action = nil
         action = event(SDL.event_type(SDL.event), controls) while action.nil? && SDL.SDL_PollEvent(SDL.event) != 0
@@ -126,26 +122,30 @@ module Badline
         SDL.SDL_SetTextureColorMod(texture, 255, 255, 255)
         draw
         SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
-        SDL.SDL_RenderPresent(renderer)
-        SDL.SDL_Delay(10)
         action
       end
 
+      # Centres the menu on a screen `width` by `height`.
+      def center(width, height)
+        @left = (width - WIDTH) / 2
+        @top = (height - HEIGHT) / 2
+      end
+
       def draw
         painter = @painter
         @buttons.forget
-        painter.box(LEFT, TOP, WIDTH, HEIGHT, PANEL)
-        painter.box(LEFT, TOP + 24, WIDTH, 1, EDGE)
-        painter.text(LEFT + 8, TOP + 9, "PAUSED", BRIGHT)
+        painter.box(@left, @top, WIDTH, HEIGHT, PANEL)
+        painter.box(@left, @top + 24, WIDTH, 1, EDGE)
+        painter.text(@left + 8, @top + 9, "PAUSED", BRIGHT)
         resume = "RESUME"
-        @buttons.plain(LEFT + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), TOP + 7, resume, :resume)
-        return @dialogs.draw(LEFT + 8, TOP + 34, WIDTH - 16) if @dialogs.open?
+        @buttons.plain(@left + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), @top + 7, resume, :resume)
+        return @dialogs.draw(@left + 8, @top + 34, WIDTH - 16) if @dialogs.open?
 
-        painter.box(BODY - 8, TOP + 32, 1, HEIGHT - 56, EDGE)
+        painter.box(@left + BODY - 8, @top + 32, 1, HEIGHT - 56, EDGE)
         draw_sections
-        @buttons.plain(LEFT + 6, TOP + HEIGHT - 28, "QUICK OPEN...", :quick_open)
-        painter.text(LEFT + 8, TOP + HEIGHT - 12, "F9/ESC: RESUME", DIM)
-        @pages.draw(PAGES[@section], BODY, TOP + 34)
+        @buttons.plain(@left + 6, @top + HEIGHT - 28, "QUICK OPEN...", :quick_open)
+        painter.text(@left + 8, @top + HEIGHT - 12, "F9/ESC: RESUME", DIM)
+        @pages.draw(PAGES[@section], @left + BODY, @top + 34)
       end
 
       private
@@ -165,6 +165,8 @@ module Badline
       end
 
       def menu_action(action)
+        return snapshot_action(action) if SNAPSHOT_ACTIONS.include?(action) || MenuPages::RECENT.include?(action)
+
         case action
         when :insert_disk then @dialogs.browse(:disk)
         when :insert_tape then @dialogs.browse(:tape)
@@ -176,6 +178,19 @@ module Badline
         nil
       end
 
+      # Saves now, asks for a name to save under, opens the saves folder,
+      # or loads one of the page's quicksaves and autosaves, returning
+      # :swap once a save has loaded.
+      def snapshot_action(action)
+        case action
+        when :quicksave_now then @snapshots.quicksave
+        when :save_as then @dialogs.ask_name(@snapshots.free_name(@pages.media.game_name))
+        when :load_save then @dialogs.browse(:snapshot)
+        else return @dialogs.load(@pages.recent(action))
+        end
+        nil
+      end
+
       # Moves the focus: down from RESUME to the sections, through them,
       # where each opens as it's reached, on to Quick open, right into a
       # page, up and down it, and left out of it again.
@@ -235,9 +250,9 @@ module Badline
       end
 
       def draw_sections
-        top = TOP + 32
+        top = @top + 32
         SECTIONS.each_with_index do |name, index|
-          @buttons.plain(LEFT + 6, top, name.ljust(14), PAGES[index], on: index == @section)
+          @buttons.plain(@left + 6, top, name.ljust(14), PAGES[index], on: index == @section)
           top += Buttons::HEIGHT + 2
         end
       end

data/lib/badline/frontend/player_screen.rb

@@ -10,7 +10,7 @@ module Badline
       HEADER = 64
       SCALE = 2
       TITLE = "Badline"
-      BACKGROUND = Screen::COLORS[6]
+      BACKGROUND = VIC::PALETTE[6]
 
       attr_reader :buttons, :info
 

data/lib/badline/frontend/player_window.rb

@@ -23,7 +23,7 @@ module Badline
       UP = 82
       DOWN = 81
 
-      WARNING = Screen::COLORS[10]
+      WARNING = VIC::PALETTE[10]
 
       CHIPS = PlayerHeader::CHIPS
 
@@ -45,7 +45,7 @@ module Badline
         @state = PlayerState.new
         @commands = PlayerCommands.new(@state)
         @next_draw = 0.0
-        @seek_left = 0
+        @seek_to = 0.0
         @dropped = []
         @credits = []
         @stil = []
@@ -55,7 +55,7 @@ module Badline
       end
 
       # The seconds into the subtune the last click on the bar asked for.
-      def seek_to = PlayerFooter.seek(@seek_left, @state.length)
+      attr_reader :seek_to
 
       # The files dropped on the window since it last said :drop.
       def dropped
@@ -175,7 +175,7 @@ module Badline
         action = @screen.buttons.action_at(left, SDL.event_y(SDL.event))
         return if action.nil?
 
-        @seek_left = left if action == :seek
+        @seek_to = PlayerFooter.seek(left, @state.length) if action == :seek
         return scroll_along if action == :scroll
 
         command(action, actions)

data/lib/badline/frontend/screen.rb

@@ -2,60 +2,62 @@
 
 module Badline
   module Frontend
-    # The visible part of the VIC's display, the crop of the machine's
-    # region, repacked for an SDL texture in XRGB8888. Spinel hands an
-    # Array of Integers to C as 64-bit words, as badline/ffi does on CRuby,
-    # so each word carries two neighbouring pixels, the left one in the low
-    # half. The texture is PAL's crop, 384x272, and a region with fewer
-    # lines to show sits in the middle of it, between black bands.
+    # The visible part of the video chip's display, the crop of the
+    # machine's timing, repacked for an SDL texture in XRGB8888 in the
+    # chip's palette. Spinel hands an Array of Integers to C as 64-bit
+    # words, as badline/ffi does on CRuby, so each word carries two
+    # neighbouring pixels, the left one in the low half.
+    #
+    # The texture is as wide as the crop and at least as high as PAL's
+    # C64 crop, 272 lines, so a C64 shows in the same window whatever its
+    # region: a crop with fewer lines sits in the middle of the texture,
+    # between black bands. The VIC-20's 284 by 284 crop fills its own.
     class Screen
-      WIDTH = Region::PAL.crop[2]
-      HEIGHT = Region::PAL.crop[3]
-      ROW_BYTES = WIDTH * 4
-      ROW_WORDS = WIDTH / 2
+      MIN_HEIGHT = Region::PAL.crop[3]
 
-      COLORS = [
-        0x000000, 0xffffff, 0x924a40, 0x84c5cc,
-        0x9351b6, 0x72b14b, 0x483aaa, 0xd5df7c,
-        0x675200, 0xc33d00, 0xc18178, 0x606060,
-        0x8a8a8a, 0xb3ec91, 0x867ade, 0xb3b3b3
-      ].freeze
+      attr_reader :pixels, :width, :height
 
-      PAIRS = Array.new(256) { |pair| COLORS[pair & 0x0f] | (COLORS[pair >> 4] << 32) }.freeze
-
-      attr_reader :pixels
-
-      def initialize(vic)
-        @vic = vic
-        crop = vic.region.crop
+      def initialize(video, crop)
+        @video = video
         @col_offset = crop[0]
         @row_offset = crop[1]
-        @height = crop[3]
-        @band = (HEIGHT - @height) / 2
-        @pixels = Array.new(HEIGHT * ROW_WORDS, 0)
+        @lines = crop[3]
+        @width = crop[2]
+        @stride = video.width.to_i
+        @height = [@lines, MIN_HEIGHT].max
+        @row_words = @width / 2
+        @band = (@height - @lines) / 2
+        palette = video.palette
+        @pairs = Array.new(256) { |pair| palette[pair & 0x0f] | (palette[pair >> 4] << 32) }
+        @pixels = Array.new(@height * @row_words, 0)
       end
 
-      # Repacks only the lines the VIC has changed since the last frame.
+      # The bytes of one row of the texture.
+      def row_bytes = @width * 4
+
+      # Repacks only the lines the chip has changed since the last frame.
       def update
-        dirty = @vic.dirty_lines
+        video = @video
+        dirty = video.dirty_lines
+        display = video.display
         row = 0
-        while row < @height
-          pack_row(row) if dirty[row + @row_offset]
+        while row < @lines
+          pack_row(display, row) if dirty[row + @row_offset]
           row += 1
         end
-        @vic.clear_dirty_lines!
+        video.clear_dirty_lines!
       end
 
       private
 
-      def pack_row(row)
-        display = @vic.display
+      def pack_row(display, row)
         pixels = @pixels
-        from = ((row + @row_offset) * @vic.width) + @col_offset
-        to = (row + @band) * ROW_WORDS
-        last = to + ROW_WORDS
+        pairs = @pairs
+        from = ((row + @row_offset) * @stride) + @col_offset
+        to = (row + @band) * @row_words
+        last = to + @row_words
         while to < last
-          pixels[to] = PAIRS[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
+          pixels[to] = pairs[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
           from += 2
           to += 1
         end

data/lib/badline/frontend/sid_view.rb

@@ -8,7 +8,7 @@ module Badline
     # a tune on more than one gets a row of buttons above the voices that
     # pick it, which makes the view PICKER taller.
     class SIDView
-      COLORS = Screen::COLORS
+      COLORS = VIC::PALETTE
       TEXT = COLORS[14]
       BRIGHT = COLORS[1]
       DIM = COLORS[11]

data/lib/badline/frontend/snapshots.rb

@@ -2,20 +2,26 @@
 
 module Badline
   module Frontend
-    # The window's snapshots: F11 saves the machine to a new
-    # badline-<date>-<time>.vsf in the working directory, and F12 goes back
-    # to the snapshot last saved or opened, in a new machine. --save-snapshot
-    # saves one after the last frame.
+    # The window's snapshots: F11 saves the machine to the next of five
+    # quicksave slots in the data folder, replacing the oldest, and F12
+    # restores the newest quicksave or named save in a new machine. A run
+    # without a frame limit also autosaves every AUTOSAVE_FRAMES frames to
+    # the next of three autosave slots, which only the pause menu loads.
+    # --save-snapshot saves one after the last frame.
     class Snapshots
       KEYS = [Keys::F11, Keys::F12].freeze
+      SLOTS = 5
+      AUTOSAVES = 3
+      AUTOSAVE_FRAMES = 6000
 
       # The machine running, which F12 replaces with the restored one.
       attr_accessor :computer
 
       def initialize(computer, options)
         @computer = computer
-        @last = options.snapshot? ? options.media_path.to_s : ""
         @at_finish = options.save_snapshot
+        @autosave = options.frames.zero?
+        @autosave_at = AUTOSAVE_FRAMES
       end
 
       # Saves or restores for F11 or F12, and says whether a restored
@@ -23,38 +29,160 @@ module Badline
       def key(scancode)
         return restore if scancode == Keys::F12
 
-        save if scancode == Keys::F11
+        quicksave if scancode == Keys::F11
         false
       end
 
-      # Saves the machine, and warns when it can't.
-      def save(path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf")
+      # Saves the machine to the first empty quicksave slot, or else to the
+      # one saved longest ago, and warns when it can't.
+      def quicksave
+        folder = Badline.data_folder("quicksaves")
+        slot = next_slot(folder, "quicksave", SLOTS)
+        save(slot_path(folder, "quicksave", slot), "quicksave #{slot}")
+      rescue SystemCallError => e
+        warn "badline: quicksave: #{e.message}"
+      end
+
+      # Saves the machine, and warns when it can't. Says whether it saved.
+      def save(path, name = "")
         @computer.save_snapshot(path)
-        @last = path
-        puts "Saved #{path}"
+        puts(name.empty? ? "Saved #{path}" : "Saved #{name} to #{path}")
+        true
       rescue Snapshot::FormatError, SystemCallError => e
         warn "badline: #{path}: #{e.message}"
+        false
       end
 
-      # Restores the snapshot last saved or opened into a new machine, and
+      # Restores the newest quicksave or named save into a new machine, and
       # warns when it fails, leaving the machine running as it was.
       def restore
-        if @last.empty?
-          puts "No snapshot to restore, F11 saves one"
+        path = newest
+        if path.empty?
+          puts "No quicksave to restore. F11: Quicksave"
           return false
         end
 
-        @computer = Snapshot.load(@last) { |line| puts line }
-        puts "Restored #{@last}"
-        true
+        restore_from(path)
+      rescue SystemCallError => e
+        warn "badline: quicksave: #{e.message}"
+        false
+      end
+
+      # Autosaves once the machine has run AUTOSAVE_FRAMES frames since the
+      # last, quietly. A machine that can't be saved stops autosaving after
+      # one warning.
+      def tick(frames)
+        return unless @autosave && frames >= @autosave_at
+
+        @autosave_at = frames + AUTOSAVE_FRAMES
+        folder = Badline.data_folder("autosaves")
+        @computer.save_snapshot(slot_path(folder, "autosave", next_slot(folder, "autosave", AUTOSAVES)))
       rescue Snapshot::FormatError, SystemCallError => e
-        warn "badline: #{@last}: #{e.message}"
+        @autosave = false
+        warn "badline: autosave: #{e.message}"
+      end
+
+      # The snapshots in one of the data folders, `quicksaves`, `autosaves`
+      # or `saves`, newest first.
+      def list(name)
+        folder = Badline.data_folder(name)
+        paths = Dir.children(folder).select { |child| File.extname(child).casecmp?(".vsf") }
+        paths.map { |child| File.join(folder, child) }.sort_by { |path| -modified(path) }
+      rescue SystemCallError
+        []
+      end
+
+      # Whether a save in the saves folder has the name.
+      def named?(name) = File.exist?(File.join(Badline.data_folder("saves"), "#{name}.vsf"))
+
+      # Saves the machine as `name` in the saves folder, and says whether it
+      # did: a name already taken is overwritten only with `replace`.
+      def save_named(name, replace: false)
+        path = File.join(Badline.data_folder("saves"), "#{name}.vsf")
+        return false if File.exist?(path) && !replace
+
+        save(path, name)
+      rescue SystemCallError => e
+        warn "badline: #{name}: #{e.message}"
         false
       end
 
+      # `base` and the lowest number no named save has yet.
+      def free_name(base)
+        folder = Badline.data_folder("saves")
+        number = 1
+        number += 1 while File.exist?(File.join(folder, "#{base} #{number}.vsf"))
+        "#{base} #{number}"
+      rescue SystemCallError
+        "#{base} 1"
+      end
+
+      # Restores the snapshot at `path` into a new machine, and says whether
+      # it did.
+      def load(path) = restore_from(path)
+
+      # When the snapshot at `path` was saved, as HH:MM:SS.
+      def time_of(path)
+        time = File.mtime(path)
+        format("%<hour>02d:%<minute>02d:%<second>02d", hour: time.hour, minute: time.min, second: time.sec)
+      end
+
       def finish
         save(@at_finish) unless @at_finish.empty?
       end
+
+      private
+
+      def restore_from(path)
+        @computer = Snapshot.load(path) { |line| puts line }
+        puts "Restored #{name_of(path)} from #{path}"
+        true
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+        false
+      end
+
+      def next_slot(folder, kind, count)
+        empty = (1..count).find { |slot| !File.exist?(slot_path(folder, kind, slot)) }
+        return empty unless empty.nil?
+
+        (1..count).min_by { |slot| modified(slot_path(folder, kind, slot)) }
+      end
+
+      def slot_path(folder, kind, slot) = File.join(folder, "#{kind}-#{slot}.vsf")
+
+      # The .vsf in quicksaves/ or saves/ written last, or "" when there's
+      # none.
+      def newest
+        found = ""
+        found_at = 0
+        %w[quicksaves saves].each do |name|
+          folder = Badline.data_folder(name)
+          Dir.children(folder).each do |child|
+            next unless File.extname(child).casecmp?(".vsf")
+
+            path = File.join(folder, child)
+            at = modified(path)
+            next unless found.empty? || at > found_at
+
+            found = path
+            found_at = at
+          end
+        end
+        found
+      end
+
+      def name_of(path)
+        folder = Badline.data_folder("quicksaves")
+        slot = (1..SLOTS).find { |n| slot_path(folder, "quicksave", n) == path }
+        slot.nil? ? File.basename(path, ".vsf") : "quicksave #{slot}"
+      end
+
+      # The modification time in nanoseconds.
+      def modified(path)
+        time = File.mtime(path)
+        (time.tv_sec * 1_000_000_000) + time.nsec
+      end
     end
   end
 end