rubyboy 1.5.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22c8e1f0094ec086f0e7130e6c79623d0e9385c718f0724ca2773c101ff3b976
-  data.tar.gz: 49adde27b593ef7bf8bf3f874160922ed7994388960db71f5757b2cbf033735f
+  metadata.gz: 715ec944430fe6b0f108f1a51dc90722059e754939ca8e23726fb8c9ca226407
+  data.tar.gz: 12b42b656684bc9b4255559aaec3600c6fa4d6f32132fc144666de097f7512a0
 SHA512:
-  metadata.gz: 48abbc79e8dde1e691f3f76a2736ad909b29af549c3c3b6a99eedd16a5b832f8b84bfb810ed4115483e116f5acbd50e1b07ec333e61778dc82433293f36a8401
-  data.tar.gz: dcf874037cd1d133687e3a99c5aeb36d97cd8a8f356514bb97b40eec57184b3bed7bd003538925fce18875d13d8bd37e1f50ffdd646568b5fbc351925f710a5a
+  metadata.gz: 0d5c32193c766397003bb8d2bfc1072dc8dd0dbca967dbd87c2e041b4559f6f43aa761452fa68acc3036b08e2a5606f96df15733284fa7f1c880e07c9061de57
+  data.tar.gz: 1f514d729da361a7ede186479b8ad844c7d57d04fec572d1d2c02fdcd7f86e82d7d8ebb603596369eb3800e5ed389aae79fa3b3a9bb094cfe137c3c3e553a44d

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [1.7.0] - 2026-10-10
+
+- Require Ruby 4.0 or higher
+- Keep audio output with --unlimited by dropping audio that cannot be played in time
+- Remove the --no-audio player option
+- Remove rubyboy-bench --render and --json, and the SDL 2.0.18 requirement
+- Print a checksum of the final frame from rubyboy-bench to check that a runtime emulated correctly
+- Run rubyboy-bench without loading SDL
+- Run the bundled Tobu Tobu Girl ROM when rubyboy or rubyboy-bench gets no ROM path, from any directory
+- Read ROM files in binary mode, which fixes loading them on Windows
+- Make the APU duty tables shareable between Ractors
+- Ship only the runtime code, the default ROM and documents in the gem, without the rubyboy-wasm command or test ROMs
+
+## [1.6.0] - 2026-10-04
+
+- Add battery-backed saves and hardware-oriented save states
+- Fix MBC1 ROM bank mapping, external RAM size and RAM banking
+- Fix audio drop-outs and APU sample-rate drift
+- Support Spinel compilation and fix SDL event allocation
+- Add --frames, --unlimited and --no-audio player options
+- Add benchmark warmup, SDL rendering and JSON output
+- Disable VSync for rendered benchmarks and require SDL 2.0.18 or higher
+- Update JSON and development dependencies for recent Ruby versions
+
 ## [1.5.1] - 2025-02-16
 
 - Optimize Cartridge::Mbc1 and Bus

data/README.md

@@ -6,7 +6,9 @@
 
 A Game Boy emulator written in Ruby
 
-**[Try the demo in your browser!](https://sacckey.github.io/rubyboy/)** - Powered by WebAssembly
+**Try it in your browser:**
+[ruby.wasm version](https://sacckey.github.io/rubyboy/) (CRuby compiled to WebAssembly) /
+[Spinel version](https://sacckey.github.io/rubyboy/spinel/) (the same Ruby code compiled to C by Spinel, then to WebAssembly)
 
 ## Screenshots
 <div align="center">
@@ -14,47 +16,57 @@ A Game Boy emulator written in Ruby
   <img src="/resource/screenshots/puyopuyo.png" width="400px"/>
 </div>
 
-## Requirements
-[SDL2](https://wiki.libsdl.org/SDL2/Installation)
-
 ## Installation
 
-This project requires Ruby 3.2.0 or higher.
+Rubyboy requires Ruby 4.0 or higher and [SDL2](https://wiki.libsdl.org/SDL2/Installation).
+
+    $ gem install rubyboy
 
 > [!TIP]
-> To enhance performance, it is highly recommended to use Ruby 3.3.x with YJIT.
+> Run with YJIT (`RUBYOPT=--yjit`) for better performance.
+
+## Usage
 
-Install the gem and add to the application's Gemfile by executing:
+    $ RUBYOPT=--yjit rubyboy [rom_path]
 
-    $ bundle add rubyboy
+Without a ROM path, it runs the bundled [Tobu Tobu Girl](https://tangramgames.dk/tobutobugirl/).
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+### Controls
 
-    $ gem install ffi rubyboy
+| Key | Button |
+| :---: | :---: |
+| `W` `A` `S` `D` | ↑ ← ↓ → |
+| `K` | A |
+| `J` | B |
+| `U` | Select |
+| `I` | Start |
+| `1`–`0` | Save state to slot 1–9, 0 |
+| Left `Shift` + `1`–`0` | Load state from that slot |
 
-## Usage
+Battery-backed games save to `<rom>.sav`, and save states go to `<rom>.state<N>`,
+next to the ROM file.
+
+### Options
 
-    $ RUBYOPT=--yjit rubyboy <rom_path>
+| Option | Effect |
+| --- | --- |
+| `--frames N` | Exit after N frames |
+| `--unlimited` | Run as fast as possible; audio that cannot be played in time is dropped |
 
-| Key   | Button |
-| :---: | :----: |
-| `W`   | ↑      |
-| `A`   | ←      |
-| `S`   | ↓      |
-| `D`   | →      |
-| `J`   | A      |
-| `K`   | B      |
-| `U`   | Select |
-| `I`   | Start  |
+## Benchmark
+
+On an Apple M4, Rubyboy runs at about 110 FPS on CRuby, 290 FPS with YJIT and
+800 FPS when compiled with Spinel. See [BENCHMARK.md](BENCHMARK.md) for the method and details.
+
+## Other ways to run
+
+- [WebAssembly builds](wasm/README.md): the browser versions (ruby.wasm and Spinel)
+- [Spinel](spinel/README.md): compile Rubyboy to a native executable
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/sacckey/rubyboy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/sacckey/rubyboy/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/sacckey/rubyboy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](CODE_OF_CONDUCT.md).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Rubyboy project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/sacckey/rubyboy/blob/main/CODE_OF_CONDUCT.md).

data/exe/rubyboy

@@ -4,22 +4,33 @@
 require 'rubyboy'
 require 'optparse'
 
+frames = nil
+realtime = true
+
 begin
   OptionParser.new do |opts|
-    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} ROM_PATH"
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [ROM_PATH]"
+
+    opts.on('--frames N', 'Exit after N frames (positive integer)') do |value|
+      value = Integer(value)
+      raise OptionParser::InvalidArgument, 'frames must be a positive integer' unless value > 0
+
+      frames = value
+    end
+    opts.on('--unlimited', 'Disable real-time synchronization; excess audio is dropped') { realtime = false }
 
     opts.on('-h', '--help', 'Displays this help') do
       puts opts
       exit
     end
   end.parse!
-rescue OptionParser::ParseError => e
+rescue OptionParser::ParseError, ArgumentError => e
   puts e.message
-  puts "Usage: #{File.basename($PROGRAM_NAME)} ROM_PATH"
+  puts "Usage: #{File.basename($PROGRAM_NAME)} [ROM_PATH]"
   exit 1
 end
 
-rom_path = ARGV.shift || 'lib/roms/tobu.gb'
+rom_path = ARGV.shift || Rubyboy::Rom::DEFAULT_PATH
 
 puts "Ruby: #{RUBY_VERSION}"
 if defined?(RubyVM::YJIT)
@@ -28,4 +39,4 @@ else
   puts 'YJIT is not available in this environment.'
 end
 
-Rubyboy::Emulator.new(rom_path).start
+Rubyboy::Emulator.new(rom_path).start(frames:, realtime:)

data/exe/rubyboy-bench

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'rubyboy'
 require 'bench'
 require 'optparse'
 
@@ -10,14 +9,18 @@ begin
   OptionParser.new do |opts|
     opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options]"
 
-    opts.on('--count COUNT', Integer, 'Number of counts for the benchmark') do |count|
+    opts.on('--count COUNT', Integer, 'Number of trials for the benchmark') do |count|
       options[:count] = count
     end
 
-    opts.on('--frames FRAMES', Integer, 'Number of frames to process') do |frames|
+    opts.on('--frames FRAMES', Integer, 'Number of measured frames per trial') do |frames|
       options[:frames] = frames
     end
 
+    opts.on('--warmup-frames FRAMES', Integer, 'Number of unmeasured warmup frames per trial (default: 0)') do |frames|
+      options[:warmup_frames] = frames
+    end
+
     opts.on('--rom-path ROM_PATH', String, 'Path to the ROM file') do |rom_path|
       options[:rom_path] = rom_path
     end
@@ -27,9 +30,9 @@ begin
       exit
     end
   end.parse!
-rescue OptionParser::ParseError => e
-  puts e.message
-  puts "Usage: #{File.basename($PROGRAM_NAME)} --count NUM --frames NUM --rom-path FILEPATH"
+rescue OptionParser::ParseError, ArgumentError => e
+  warn e.message
+  warn "Usage: #{File.basename($PROGRAM_NAME)} --count NUM --frames NUM --rom-path FILEPATH"
   exit 1
 end
 
@@ -40,4 +43,9 @@ else
   puts 'YJIT is not available in this environment.'
 end
 
-Rubyboy::Bench.new.run(**options)
+begin
+  Rubyboy::Bench.new.run(**options)
+rescue ArgumentError => e
+  warn e.message
+  exit 1
+end

data/lib/bench.rb

@@ -4,24 +4,50 @@ require_relative 'rubyboy/emulator_headless'
 
 module Rubyboy
   class Bench
-    def run(count: 3, frames: 1500, rom_path: 'lib/roms/tobu.gb')
-      time_sum = 0
+    def run(count: 3, frames: 1500, rom_path: Rom::DEFAULT_PATH, warmup_frames: 0)
+      validate_integer(:count, count, 1)
+      validate_integer(:frames, frames, 1)
+      validate_integer(:warmup_frames, warmup_frames, 0)
 
+      time_sum = 0
+      frame_checksum = 0
       count.times do |i|
         emulator = Rubyboy::EmulatorHeadless.new(rom_path)
-        frame_count = 0
+        run_frames(emulator, warmup_frames)
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
-        while frame_count < frames
-          emulator.step
-          frame_count += 1
-        end
+        run_frames(emulator, frames)
         time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
         puts "#{i + 1}: #{time / 1_000_000_000.0} sec"
 
         time_sum += time
+        frame_checksum = checksum(emulator.framebuffer)
       end
 
       puts "FPS: #{frames * count * 1_000_000_000.0 / time_sum}"
+      # Every trial ends on the same frame. A different value on another runtime means it emulated incorrectly.
+      puts "Checksum: #{frame_checksum}"
+    end
+
+    private
+
+    def validate_integer(name, value, minimum)
+      return if value.is_a?(Integer) && value >= minimum
+
+      requirement = minimum == 0 ? 'a nonnegative integer' : 'a positive integer'
+      raise ArgumentError, "#{name} must be #{requirement}"
+    end
+
+    # Integer arithmetic only, so CRuby and ahead-of-time compilers such as Spinel produce the same value.
+    def checksum(framebuffer)
+      framebuffer.reduce(0) { |hash, pixel| ((hash * 31) + pixel) & 0xffffffff }
+    end
+
+    def run_frames(emulator, frames)
+      frame_count = 0
+      while frame_count < frames
+        emulator.step
+        frame_count += 1
+      end
     end
   end
 end

data/lib/executor.rb

@@ -1,36 +1,45 @@
 # frozen_string_literal: true
 
-require 'js'
-require 'json'
-
 require_relative 'rubyboy/emulator_wasm'
 
 class Executor
   ALLOWED_ROMS = ['tobu.gb', 'bgbtest.gb'].freeze
 
-  def initialize
-    rom_data = File.open('lib/roms/tobu.gb', 'r') { _1.read.bytes }
+  def initialize(rom_path = '/lib/roms/tobu.gb')
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
 
   def exec(direction_key = 0b1111, action_key = 0b1111)
-    bin = @emulator.step(direction_key, action_key).pack('V*')
-    File.binwrite('/video.data', bin)
+    @emulator.step(direction_key, action_key)
+    write_framebuffer
+    write_audio
   end
 
   def read_rom_from_virtual_fs
     rom_path = '/rom.data'
     raise "ROM file not found in virtual filesystem at #{rom_path}" unless File.exist?(rom_path)
 
-    rom_data = File.open(rom_path, 'rb') { |file| file.read.bytes }
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
 
   def read_pre_installed_rom(rom_name)
     raise 'ROM not found in allowed ROMs' unless ALLOWED_ROMS.include?(rom_name)
 
-    rom_path = File.join('lib/roms', rom_name)
-    rom_data = File.open(rom_path, 'r') { _1.read.bytes }
+    rom_path = File.join('/lib/roms', rom_name)
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
+
+  private
+
+  def write_framebuffer
+    File.binwrite('/video.data', @emulator.framebuffer.pack('V*'))
+  end
+
+  def write_audio
+    samples = @emulator.audio_samples
+    File.binwrite('/audio.data', samples.pack('e*')) unless samples.empty?
+  end
 end

data/lib/rubyboy/apu.rb

@@ -7,13 +7,24 @@ require_relative 'apu_channels/channel4'
 
 module Rubyboy
   class Apu
+    # APU samples are pushed to SDL at 48 kHz (must match Rubyboy::Audio::SAMPLE_RATE).
+    # The CPU runs at 4_194_304 Hz, so the real divisor is 87.3813...
+    # The previous implementation used `>= 87` which effectively ran the sampler
+    # at ~48_210 Hz — a 0.4% drift that slowly over-filled the SDL audio queue
+    # and triggered the clear-on-overflow in Audio#queue, producing audible gaps
+    # in BGM. We fix this with a fixed-point accumulator that targets the exact
+    # ratio: every step adds `cycles * SAMPLE_RATE` and we emit one sample
+    # whenever the accumulator reaches CPU_CLOCK_HZ.
+    CPU_CLOCK_HZ = 4_194_304
+    SAMPLE_RATE = 48_000
+
     attr_reader :samples
 
     def initialize
       @nr50 = 0
       @nr51 = 0
       @cycles = 0
-      @sampling_cycles = 0
+      @sampling_accumulator = 0
       @fs = 0
       @samples = Array.new(1024, 0.0)
       @sample_idx = 0
@@ -25,7 +36,7 @@ module Rubyboy
 
     def step(cycles)
       @cycles += cycles
-      @sampling_cycles += cycles
+      @sampling_accumulator += cycles * SAMPLE_RATE
 
       @channel1.step(cycles)
       @channel2.step(cycles)
@@ -43,8 +54,8 @@ module Rubyboy
         @fs = (@fs + 1) % 8
       end
 
-      if @sampling_cycles >= 87
-        @sampling_cycles -= 87
+      if @sampling_accumulator >= CPU_CLOCK_HZ
+        @sampling_accumulator -= CPU_CLOCK_HZ
 
         left_sample = (
           @nr51[7] * @channel4.dac_output +

data/lib/rubyboy/apu_channels/channel1.rb

@@ -6,10 +6,10 @@ module Rubyboy
       attr_accessor :enabled, :wave_duty_position
 
       WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0].freeze, # 12.5%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0].freeze, # 25%
+        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0].freeze, # 50%
+        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0].freeze  # 75%
       ].freeze
 
       def initialize

data/lib/rubyboy/apu_channels/channel2.rb

@@ -6,10 +6,10 @@ module Rubyboy
       attr_accessor :enabled, :wave_duty_position
 
       WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0].freeze, # 12.5%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0].freeze, # 25%
+        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0].freeze, # 50%
+        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0].freeze  # 75%
       ].freeze
 
       def initialize

data/lib/rubyboy/apu_channels/channel3.rb

@@ -5,13 +5,6 @@ module Rubyboy
     class Channel3
       attr_accessor :enabled, :wave_duty_position, :wave_ram
 
-      WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
-      ].freeze
-
       def initialize
         @cycles = 0
         @frequency = 0
@@ -76,9 +69,9 @@ module Rubyboy
       def dac_output
         return 0.0 unless @dac_enabled && @enabled
 
-        ret = ((0xf & (
+        ret = (0xf & (
           @wave_ram[@wave_duty_position >> 1] >> ((@wave_duty_position & 0x01) << 2)
-        ))) >> @volume_shift
+        )) >> @volume_shift
 
         (ret / 7.5) - 1.0
       end

data/lib/rubyboy/apu_channels/channel4.rb

@@ -5,13 +5,6 @@ module Rubyboy
     class Channel4
       attr_accessor :enabled, :wave_duty_position
 
-      WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
-      ].freeze
-
       def initialize
         @cycles = 0
         @frequency = 0

data/lib/rubyboy/audio.rb

@@ -21,15 +21,28 @@ module Rubyboy
       SDL.PauseAudioDevice(@device, 0)
     end
 
-    def queue(buffer)
-      # sleep(0.001) while SDL.GetQueuedAudioSize(@device) > 8192
-
-      SDL.ClearQueuedAudio(@device) if SDL.GetQueuedAudioSize(@device) > 8192
+    def queue(buffer, wait: true)
+      # Block until the SDL audio queue has drained enough to accept another
+      # buffer. The previous implementation called SDL.ClearQueuedAudio here
+      # instead, which dropped the entire queue whenever the emulator ran ahead
+      # of real time — that produced audible pops/gaps in BGM (most noticeable
+      # in Pokemon-style tracks). Blocking here costs a tiny bit of frame
+      # budget but keeps audio continuous.
+      # Unlimited playback drops this buffer instead, so audio never slows it down.
+      while SDL.GetQueuedAudioSize(@device) > 8192
+        return unless wait
+
+        sleep(0.001)
+      end
 
       buf_ptr = FFI::MemoryPointer.new(:float, buffer.size)
       buf_ptr.put_array_of_float(0, buffer)
 
       SDL.QueueAudio(@device, buf_ptr, buffer.size * buf_ptr.type_size)
     end
+
+    def clear_queue
+      SDL.ClearQueuedAudio(@device)
+    end
   end
 end

data/lib/rubyboy/cartridge/mbc1.rb

@@ -3,6 +3,9 @@
 module Rubyboy
   module Cartridge
     class Mbc1
+      ROM_BANK_SIZE = 0x4000
+      RAM_BANK_SIZE = 0x2000
+
       def initialize(rom, ram)
         @rom = rom
         @ram = ram
@@ -15,19 +18,13 @@ module Rubyboy
       def read_byte(addr)
         case (addr >> 12)
         when 0x0, 0x1, 0x2, 0x3
-          @rom.data[addr]
+          @rom.data[rom_offset(addr)] || 0xff
         when 0x4, 0x5, 0x6, 0x7
-          @rom.data[addr + ((@rom_bank - 1) << 14)]
+          @rom.data[rom_offset(addr)] || 0xff
         when 0xa, 0xb
-          if @ram_enable
-            if @ram_banking_mode
-              @ram.eram[addr - 0xa000 + (@ram_bank << 11)]
-            else
-              @ram.eram[addr - 0xa000]
-            end
-          else
-            0xff
-          end
+          return 0xff unless @ram_enable
+
+          @ram.eram[ram_offset(addr)] || 0xff
         end
       end
 
@@ -43,15 +40,30 @@ module Rubyboy
         when 0x6, 0x7
           @ram_banking_mode = value & 0x01 == 0x01
         when 0xa, 0xb
-          if @ram_enable
-            if @ram_banking_mode
-              @ram.eram[addr - 0xa000 + (@ram_bank << 11)] = value
-            else
-              @ram.eram[addr - 0xa000] = value
-            end
-          end
+          return unless @ram_enable
+
+          offset = ram_offset(addr)
+          @ram.eram[offset] = value if offset < @ram.eram.size
         end
       end
+
+      private
+
+      def rom_offset(addr)
+        bank =
+          if addr < ROM_BANK_SIZE
+            @ram_banking_mode ? (@ram_bank << 5) : 0
+          else
+            (@ram_bank << 5) | @rom_bank
+          end
+
+        ((bank * ROM_BANK_SIZE) + (addr & (ROM_BANK_SIZE - 1))) % @rom.data.size
+      end
+
+      def ram_offset(addr)
+        bank = @ram_banking_mode ? @ram_bank : 0
+        (addr - 0xa000) + (bank * RAM_BANK_SIZE)
+      end
     end
   end
 end