vizcore 0.1.0 → 1.0.0

data/lib/vizcore/analysis/feature_recorder.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+require_relative "../audio/file_input"
+require_relative "../audio/input_manager"
+require_relative "pipeline"
+
+module Vizcore
+  module Analysis
+    # Records deterministic audio analysis features from a file source.
+    class FeatureRecorder
+      VERSION = "vizcore.features.v1"
+      DEFAULT_FRAME_COUNT = 300
+      DEFAULT_FRAME_RATE = 30.0
+
+      def initialize(
+        audio_file:,
+        frames: DEFAULT_FRAME_COUNT,
+        fps: DEFAULT_FRAME_RATE,
+        noise_gate: Pipeline::DEFAULT_NOISE_GATE,
+        audio_normalize: nil,
+        bpm: nil,
+        bpm_lock: false
+      )
+        @audio_file = Pathname.new(audio_file.to_s).expand_path
+        @frames = normalize_frame_count(frames)
+        @fps = normalize_frame_rate(fps)
+        @noise_gate = Float(noise_gate)
+        @audio_normalize = audio_normalize
+        @bpm = bpm
+        @bpm_lock = bpm_lock
+      end
+
+      # @param out [String, Pathname] JSON output path
+      # @return [Hash] recorder metadata
+      def write(out:)
+        output_path = Pathname.new(out.to_s).expand_path
+        FileUtils.mkdir_p(output_path.dirname)
+        payload = record
+        output_path.write("#{JSON.pretty_generate(payload)}\n")
+        {
+          path: output_path,
+          frames: @frames,
+          fps: @fps,
+          sample_rate: payload.fetch("metadata").fetch("sample_rate")
+        }
+      end
+
+      private
+
+      def record
+        validate_audio_file!
+        input = Vizcore::Audio::FileInput.new(path: @audio_file.to_s)
+        raise ArgumentError, input.last_error.message if input.last_error
+
+        input.start
+        sample_rate = input.stream_sample_rate
+        capture_size = capture_size_for(sample_rate)
+        pipeline = build_pipeline(sample_rate)
+        features = @frames.times.map do |index|
+          {
+            "index" => index,
+            "time" => (index / @fps).round(6),
+            "audio" => serializable(pipeline.call(input.read(capture_size)))
+          }
+        end
+        payload(sample_rate: sample_rate, capture_size: capture_size, features: features)
+      ensure
+        input&.stop
+      end
+
+      def payload(sample_rate:, capture_size:, features:)
+        {
+          "version" => VERSION,
+          "metadata" => {
+            "audio_file" => @audio_file.to_s,
+            "frames" => @frames,
+            "fps" => @fps,
+            "sample_rate" => sample_rate,
+            "capture_size" => capture_size,
+            "noise_gate" => @noise_gate,
+            "bpm" => @bpm,
+            "bpm_lock" => @bpm_lock,
+            "audio_normalize" => serializable(@audio_normalize)
+          },
+          "features" => features
+        }
+      end
+
+      def build_pipeline(sample_rate)
+        Pipeline.new(
+          sample_rate: sample_rate,
+          fft_size: supported_fft_size(Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE),
+          noise_gate: @noise_gate,
+          audio_normalize: @audio_normalize,
+          bpm: @bpm,
+          bpm_lock: @bpm_lock
+        )
+      end
+
+      def validate_audio_file!
+        raise ArgumentError, "Audio file not found: #{@audio_file}" unless @audio_file.file?
+        return if Vizcore::Audio::FileInput::SUPPORTED_EXTENSIONS.include?(@audio_file.extname.downcase)
+
+        raise ArgumentError, "Unsupported audio format: #{@audio_file.extname.downcase}"
+      end
+
+      def capture_size_for(sample_rate)
+        [(sample_rate.to_f / @fps).round, 1].max
+      end
+
+      def supported_fft_size(size)
+        value = Integer(size)
+        return value if value.positive? && (value & (value - 1)).zero?
+
+        Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE
+      rescue StandardError
+        Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE
+      end
+
+      def serializable(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), output|
+            output[key.to_s] = serializable(entry)
+          end
+        when Array
+          value.map { |entry| serializable(entry) }
+        when Float
+          value.finite? ? value.round(6) : 0.0
+        when Symbol
+          value.to_s
+        else
+          value
+        end
+      end
+
+      def normalize_frame_count(value)
+        count = Integer(value)
+        raise ArgumentError, "frames must be positive" unless count.positive?
+
+        count
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "frames must be a positive integer"
+      end
+
+      def normalize_frame_rate(value)
+        rate = Float(value)
+        raise ArgumentError, "fps must be positive" unless rate.positive?
+
+        rate
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "fps must be a positive number"
+      end
+    end
+  end
+end

data/lib/vizcore/analysis/feature_replay.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require_relative "feature_recorder"
+
+module Vizcore
+  module Analysis
+    # Replays recorded analysis features as a pipeline-compatible source.
+    class FeatureReplay
+      attr_reader :metadata
+
+      def initialize(path:)
+        @path = Pathname.new(path.to_s).expand_path
+        payload = load_payload
+        @metadata = deep_symbolize(payload.fetch("metadata", {}))
+        @features = load_features(payload)
+        @cursor = 0
+      end
+
+      # @param _samples [Array<Float>, nil] ignored; replay data already contains analyzed features
+      # @return [Hash<Symbol, Object>] recorded audio analysis for the next frame
+      def call(_samples = nil)
+        audio = @features.fetch(@cursor)
+        @cursor = (@cursor + 1) % @features.length
+        deep_dup(audio)
+      end
+
+      def frame_count
+        @features.length
+      end
+
+      private
+
+      def load_payload
+        raise ArgumentError, "Feature file not found: #{@path}" unless @path.file?
+
+        payload = JSON.parse(@path.read)
+        version = payload["version"]
+        return payload if version == FeatureRecorder::VERSION
+
+        raise ArgumentError, "Unsupported feature file version: #{version.inspect}"
+      rescue JSON::ParserError => e
+        raise ArgumentError, "Invalid feature file JSON: #{e.message}"
+      end
+
+      def load_features(payload)
+        features = Array(payload["features"]).map.with_index do |entry, index|
+          audio = Hash(entry).fetch("audio", nil)
+          raise ArgumentError, "Feature frame #{index} is missing audio data" unless audio.is_a?(Hash)
+
+          deep_symbolize(audio)
+        end
+        raise ArgumentError, "Feature file contains no frames" if features.empty?
+
+        features
+      end
+
+      def deep_symbolize(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), output|
+            output[key.to_s.to_sym] = deep_symbolize(entry)
+          end
+        when Array
+          value.map { |entry| deep_symbolize(entry) }
+        else
+          value
+        end
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, entry), output| output[key] = deep_dup(entry) }
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/vizcore/analysis/pipeline.rb

@@ -4,6 +4,12 @@ module Vizcore
   module Analysis
     # End-to-end analysis pipeline from PCM samples to renderer-ready features.
     class Pipeline
+      BEAT_PULSE_DECAY = 0.86
+      BEAT_PULSE_FLOOR = 0.001
+      DEFAULT_NOISE_GATE = 0.01
+      DEFAULT_AUDIO_NORMALIZE = { mode: :off }.freeze
+      SILENCE_RESET_FRAMES = 90
+
       attr_reader :fft_processor, :band_splitter, :beat_detector, :bpm_estimator, :smoother
 
       # @param sample_rate [Integer]
@@ -12,38 +18,248 @@ module Vizcore
       # @param beat_detector [Vizcore::Analysis::BeatDetector, nil]
       # @param bpm_estimator [Vizcore::Analysis::BPMEstimator, nil]
       # @param smoother [Vizcore::Analysis::Smoother, nil]
-      def initialize(sample_rate: 44_100, fft_size: 1024, window: :hamming, beat_detector: nil, bpm_estimator: nil, smoother: nil)
+      # @param noise_gate [Numeric] RMS threshold below which input is treated as silence
+      # @param audio_normalize [Hash, nil] optional audio normalization settings
+      # @param bpm [Numeric, nil] fixed BPM value used when bpm_lock is true
+      # @param bpm_lock [Boolean] true when BPM output should stay fixed
+      def initialize(sample_rate: 44_100, fft_size: 1024, window: :hamming, beat_detector: nil, bpm_estimator: nil, smoother: nil, noise_gate: DEFAULT_NOISE_GATE, audio_normalize: nil, bpm: nil, bpm_lock: false)
         @fft_processor = FFTProcessor.new(sample_rate: sample_rate, fft_size: fft_size, window: window)
         @band_splitter = BandSplitter.new(sample_rate: sample_rate, fft_size: fft_size)
         @beat_detector = beat_detector || BeatDetector.new
-        frame_rate = sample_rate.to_f / fft_size.to_f
-        @bpm_estimator = bpm_estimator || BPMEstimator.new(frame_rate: frame_rate)
+        @analysis_frame_rate = sample_rate.to_f / fft_size.to_f
+        @bpm_estimator = bpm_estimator || BPMEstimator.new(frame_rate: @analysis_frame_rate)
         @smoother = smoother || Smoother.new(alpha: 0.35)
+        @noise_gate = normalize_noise_gate(noise_gate)
+        self.bpm_lock = { bpm: bpm, locked: bpm_lock }
+        self.audio_normalize = audio_normalize
+        @beat_pulse = 0.0
+        @last_bpm = 0.0
+        @silent_frame_count = 0
+        @previous_onset_amplitude = 0.0
+        @previous_onset_bands = {}
+      end
+
+      # @param settings [Hash, nil]
+      # @return [Hash] normalized settings
+      def audio_normalize=(settings)
+        @audio_normalize = normalize_audio_normalize(settings)
+        @normalizer = build_normalizer(@audio_normalize)
+      end
+
+      # @param settings [Hash]
+      # @return [Float, nil]
+      def bpm_lock=(settings)
+        values = symbolize_hash(settings)
+        @locked_bpm = normalize_locked_bpm(values[:bpm], bpm_lock: values[:locked])
+        @last_bpm = @locked_bpm if @locked_bpm
       end
 
       # @param samples [Array<Numeric>] audio frame samples
       # @return [Hash] normalized analysis payload consumed by frame broadcaster
       def call(samples)
+        amplitude = rms(samples)
+        if silence?(amplitude)
+          track_silent_frame(samples)
+          return silent_frame(reset_tempo: sustained_silence?)
+        end
+
+        @silent_frame_count = 0
+
         fft = @fft_processor.call(samples)
         bands = @band_splitter.call(fft[:magnitudes])
         beat = @beat_detector.call(samples)
-        bpm = @bpm_estimator.call(beat: beat[:beat])
-        amplitude = rms(samples)
-        spectrum_preview = preview_spectrum(fft[:magnitudes])
+        beat_detected = beat[:beat]
+        confidence = beat_confidence(beat)
+        @beat_pulse = beat_detected ? 1.0 : @beat_pulse * BEAT_PULSE_DECAY
+        @beat_pulse = 0.0 if @beat_pulse < BEAT_PULSE_FLOOR
+        bpm = resolve_bpm(beat_detected)
+        normalized = normalize_features(
+          amplitude: amplitude,
+          bands: bands,
+          fft: preview_spectrum(fft[:magnitudes])
+        )
+        onsets = detect_onsets(amplitude: normalized[:amplitude], bands: normalized[:bands])
+        drums = detect_drum_sources(bands: normalized[:bands], onsets: onsets[:bands])
 
         {
-          amplitude: @smoother.smooth(:amplitude, amplitude),
-          bands: @smoother.smooth_hash(bands, namespace: :bands),
-          fft: @smoother.smooth_array(spectrum_preview, namespace: :fft),
-          beat: beat[:beat],
+          amplitude: @smoother.smooth(:amplitude, normalized[:amplitude]),
+          bands: @smoother.smooth_hash(normalized[:bands], namespace: :bands),
+          fft: @smoother.smooth_array(normalized[:fft], namespace: :fft),
+          onset: onsets[:amplitude],
+          onsets: onsets[:bands],
+          drums: drums,
+          beat: beat_detected,
+          beat_confidence: confidence,
+          beat_pulse: @beat_pulse,
           beat_count: beat[:beat_count],
-          bpm: @smoother.smooth(:bpm, bpm, alpha: 0.2),
+          bpm: bpm,
           peak_frequency: fft[:peak_frequency]
         }
       end
 
       private
 
+      def silence?(amplitude)
+        amplitude < @noise_gate
+      end
+
+      def normalize_noise_gate(value)
+        Float(value).clamp(0.0, 1.0)
+      rescue ArgumentError, TypeError
+        DEFAULT_NOISE_GATE
+      end
+
+      def normalize_audio_normalize(value)
+        settings = DEFAULT_AUDIO_NORMALIZE.merge(symbolize_hash(value))
+        mode = settings[:mode].to_s.strip.to_sym
+        raise ArgumentError, "unsupported audio_normalize mode: #{settings[:mode]}" unless %i[off adaptive].include?(mode)
+
+        settings.merge(mode: mode)
+      end
+
+      def normalize_locked_bpm(value, bpm_lock:)
+        return nil unless bpm_lock
+
+        numeric = Float(value)
+        raise ArgumentError, "bpm must be positive when bpm_lock is enabled" unless numeric.positive?
+
+        numeric
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "bpm must be a positive number when bpm_lock is enabled"
+      end
+
+      def build_normalizer(settings)
+        return nil unless settings[:mode] == :adaptive
+
+        AdaptiveNormalizer.new(
+          window_size: normalization_window_size(settings),
+          target: settings.fetch(:target, AdaptiveNormalizer::DEFAULT_TARGET),
+          floor: settings.fetch(:floor, AdaptiveNormalizer::DEFAULT_FLOOR)
+        )
+      end
+
+      def normalization_window_size(settings)
+        return settings[:window_size] if settings.key?(:window_size)
+
+        seconds = settings.fetch(:window, nil)
+        return AdaptiveNormalizer::DEFAULT_WINDOW_SIZE if seconds.nil?
+
+        (Float(seconds) * @analysis_frame_rate).round.clamp(1, 10_000)
+      rescue ArgumentError, TypeError
+        AdaptiveNormalizer::DEFAULT_WINDOW_SIZE
+      end
+
+      def normalize_features(amplitude:, bands:, fft:)
+        return { amplitude: amplitude, bands: bands, fft: fft } unless @normalizer
+
+        @normalizer.call(amplitude: amplitude, bands: bands, fft: fft)
+      end
+
+      def detect_onsets(amplitude:, bands:)
+        current_amplitude = Float(amplitude).clamp(0.0, 1.0)
+        current_bands = Hash(bands).transform_values { |value| Float(value).clamp(0.0, 1.0) }
+
+        amplitude_onset = positive_delta(current_amplitude, @previous_onset_amplitude)
+        band_onsets = current_bands.each_with_object({}) do |(key, value), output|
+          output[key] = positive_delta(value, @previous_onset_bands[key].to_f)
+        end
+
+        @previous_onset_amplitude = current_amplitude
+        @previous_onset_bands = current_bands
+
+        { amplitude: amplitude_onset, bands: band_onsets }
+      rescue ArgumentError, TypeError
+        { amplitude: 0.0, bands: {} }
+      end
+
+      def positive_delta(current, previous)
+        [current - previous, 0.0].max.clamp(0.0, 1.0)
+      end
+
+      def detect_drum_sources(bands:, onsets:)
+        band_values = Hash(bands)
+        onset_values = Hash(onsets)
+
+        {
+          kick: drum_confidence([:sub, :low], band_values, onset_values),
+          snare: drum_confidence([:mid], band_values, onset_values),
+          hihat: drum_confidence([:high], band_values, onset_values)
+        }
+      end
+
+      def drum_confidence(keys, bands, onsets)
+        level = keys.map { |key| Float(bands[key] || 0.0) }.max || 0.0
+        rise = keys.map { |key| Float(onsets[key] || 0.0) }.max || 0.0
+        (level * rise).clamp(0.0, 1.0)
+      rescue ArgumentError, TypeError
+        0.0
+      end
+
+      def silent_frame(reset_tempo:)
+        @beat_pulse = 0.0
+        reset_tempo_state if reset_tempo
+        @smoother.reset if @smoother.respond_to?(:reset)
+        @previous_onset_amplitude = 0.0
+        @previous_onset_bands = {}
+
+        {
+          amplitude: 0.0,
+          bands: { sub: 0.0, low: 0.0, mid: 0.0, high: 0.0 },
+          fft: Array.new(32, 0.0),
+          onset: 0.0,
+          onsets: { sub: 0.0, low: 0.0, mid: 0.0, high: 0.0 },
+          drums: { kick: 0.0, snare: 0.0, hihat: 0.0 },
+          beat: false,
+          beat_confidence: 0.0,
+          beat_pulse: 0.0,
+          beat_count: current_beat_count,
+          bpm: @last_bpm,
+          peak_frequency: 0.0
+        }
+      end
+
+      def reset_tempo_state
+        @last_bpm = @locked_bpm || 0.0
+        @bpm_estimator.reset if @bpm_estimator.respond_to?(:reset)
+      end
+
+      def track_silent_frame(samples)
+        @silent_frame_count += 1
+        @beat_detector.call(samples) if @beat_detector.respond_to?(:call)
+        @last_bpm = @bpm_estimator.call(beat: false).to_f if @bpm_estimator.respond_to?(:call)
+      rescue StandardError
+        nil
+      end
+
+      def sustained_silence?
+        @silent_frame_count == SILENCE_RESET_FRAMES
+      end
+
+      def current_beat_count
+        return Integer(@beat_detector.beat_count) if @beat_detector.respond_to?(:beat_count)
+
+        0
+      rescue StandardError
+        0
+      end
+
+      def beat_confidence(beat)
+        threshold = Float(beat[:threshold])
+        instant_energy = Float(beat[:instant_energy])
+        return beat[:beat] ? 1.0 : 0.0 unless threshold.positive?
+
+        (instant_energy / threshold).clamp(0.0, 1.0)
+      rescue ArgumentError, TypeError
+        beat[:beat] ? 1.0 : 0.0
+      end
+
+      def resolve_bpm(beat_detected)
+        return @last_bpm = @locked_bpm if @locked_bpm
+
+        bpm = @bpm_estimator.call(beat: beat_detected)
+        @last_bpm = @smoother.smooth(:bpm, bpm, alpha: 0.2).to_f
+      end
+
       def preview_spectrum(magnitudes, bins: 32)
         values = Array(magnitudes)
         return Array.new(bins, 0.0) if values.empty?
@@ -67,6 +283,14 @@ module Vizcore
       rescue ArgumentError, TypeError
         0.0
       end
+
+      def symbolize_hash(value)
+        Hash(value).each_with_object({}) do |(key, entry), output|
+          output[key.to_sym] = entry
+        end
+      rescue StandardError
+        {}
+      end
     end
   end
 end

data/lib/vizcore/analysis/tap_tempo.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Vizcore
+  module Analysis
+    # Estimates a fixed BPM from manual tap timestamps.
+    class TapTempo
+      DEFAULT_MIN_BPM = 40.0
+      DEFAULT_MAX_BPM = 240.0
+      DEFAULT_HISTORY_SIZE = 4
+      DEFAULT_RESET_AFTER_MS = 2_500.0
+
+      def initialize(
+        min_bpm: DEFAULT_MIN_BPM,
+        max_bpm: DEFAULT_MAX_BPM,
+        history_size: DEFAULT_HISTORY_SIZE,
+        reset_after_ms: DEFAULT_RESET_AFTER_MS
+      )
+        @min_bpm = Float(min_bpm)
+        @max_bpm = Float(max_bpm)
+        @history_size = Integer(history_size).clamp(1, 16)
+        @reset_after_ms = Float(reset_after_ms)
+        @last_tap_ms = nil
+        @intervals = []
+      end
+
+      # @param timestamp_ms [Numeric] tap timestamp in milliseconds
+      # @return [Float, nil] estimated BPM after at least two taps
+      def tap(timestamp_ms:)
+        current = Float(timestamp_ms)
+        reset_if_stale(current)
+        return remember_first_tap(current) unless @last_tap_ms
+
+        interval = current - @last_tap_ms
+        @last_tap_ms = current
+        return nil unless valid_interval?(interval)
+
+        @intervals << interval
+        @intervals.shift while @intervals.length > @history_size
+        bpm_from_intervals
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      private
+
+      def reset_if_stale(current)
+        return unless @last_tap_ms
+        return unless current - @last_tap_ms > @reset_after_ms
+
+        @last_tap_ms = nil
+        @intervals.clear
+      end
+
+      def remember_first_tap(current)
+        @last_tap_ms = current
+        nil
+      end
+
+      def valid_interval?(interval)
+        return false unless interval.positive?
+
+        bpm = 60_000.0 / interval
+        bpm.between?(@min_bpm, @max_bpm)
+      end
+
+      def bpm_from_intervals
+        return nil if @intervals.empty?
+
+        average_interval = @intervals.sum / @intervals.length.to_f
+        (60_000.0 / average_interval).clamp(@min_bpm, @max_bpm)
+      end
+    end
+  end
+end

data/lib/vizcore/analysis.rb

@@ -7,8 +7,12 @@ module Vizcore
 end
 
 require_relative "analysis/band_splitter"
+require_relative "analysis/adaptive_normalizer"
 require_relative "analysis/beat_detector"
 require_relative "analysis/bpm_estimator"
 require_relative "analysis/fft_processor"
 require_relative "analysis/pipeline"
+require_relative "analysis/feature_recorder"
+require_relative "analysis/feature_replay"
 require_relative "analysis/smoother"
+require_relative "analysis/tap_tempo"

data/lib/vizcore/audio/dummy_sine_input.rb

@@ -4,7 +4,7 @@ require_relative "base_input"
 
 module Vizcore
   module Audio
-    # Deterministic sine-wave generator used as fallback/dummy source.
+    # Deterministic sine-wave generator used for the explicit dummy source.
     class DummySineInput < BaseInput
       # Default oscillator amplitude.
       DEFAULT_AMPLITUDE = 0.45

data/lib/vizcore/audio/fixture_input.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_input"
+
+module Vizcore
+  module Audio
+    # Deterministic sample-frame input for tests and repeatable development checks.
+    class FixtureInput < BaseInput
+      # @param frames [Array<Array<Numeric>>] sample frames returned in order
+      # @param sample_rate [Integer]
+      # @param loop [Boolean] whether to repeat frames after the last one
+      def initialize(frames:, sample_rate: 44_100, loop: true)
+        super(sample_rate: sample_rate)
+        @frames = normalize_frames(frames)
+        @loop = !!loop
+        @index = 0
+      end
+
+      # @param frame_size [Integer]
+      # @return [Array<Float>]
+      def read(frame_size)
+        count = Integer(frame_size)
+        return Array.new(count, 0.0) unless running?
+
+        frame = next_frame
+        return Array.new(count, 0.0) unless frame
+
+        normalize_frame_size(frame, count)
+      end
+
+      # @return [void]
+      def reset
+        @index = 0
+      end
+
+      private
+
+      def next_frame
+        return nil if @frames.empty?
+        return nil if @index >= @frames.length && !@loop
+
+        frame = @frames[@index % @frames.length]
+        @index += 1
+        frame
+      end
+
+      def normalize_frames(frames)
+        Array(frames).map do |frame|
+          values = Array(frame).map { |sample| Float(sample) }
+          raise ArgumentError, "fixture frames must not be empty" if values.empty?
+
+          values
+        end
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "fixture frames must contain numeric samples"
+      end
+
+      def normalize_frame_size(frame, count)
+        return frame.first(count) if frame.length >= count
+
+        frame + Array.new(count - frame.length, 0.0)
+      end
+    end
+  end
+end