toy 0.8.0

data/lib/toy/core/config.rb

@@ -0,0 +1,64 @@
+# lib/toy/core/config.rb — toy.yml loader.
+#
+# CRuby ONLY. Minimal project config with exactly TWO keys; an empty
+# (or absent-key) toy.yml is valid and yields ALL DEFAULTS — the roadmap
+# gate. Unknown keys warn-to-stderr (fail-loud-lite, memory
+# feedback_never_mask_fail_loud) but never abort.
+#
+# Backend is DELIBERATELY NOT a key (design: runtime-autodetected for
+# parity). Resist adding model/backend keys.
+
+require "yaml"
+
+module Toy
+  module Core
+    class Config
+      DEFAULTS = {
+        # Template for runs/<run_id>/ dir names. Brace-placeholder tokens:
+        #   {arch} {date}(YYYYMMDD) {time}(HHMMSS) {seq}(zero-padded daily)
+        # Slice 1 stores/echoes only; consumed at train time (P4).
+        "run_id_template" => "{arch}-{date}-{seq}",
+        # Relative dir the registry/discovery walks for user algos (L1-L4).
+        # Slice 1 stores only; discovery is later.
+        "algos_path" => "algos"
+      }.freeze
+
+      KNOWN_KEYS = DEFAULTS.keys.freeze
+
+      attr_reader :run_id_template, :algos_path, :source_path
+
+      def initialize(values = {})
+        merged = DEFAULTS.merge(values)
+        @run_id_template = merged["run_id_template"]
+        @algos_path = merged["algos_path"]
+      end
+
+      # Load from a toy.yml at `dir` (default: cwd). Missing file → all
+      # defaults. Empty file → all defaults. Unknown keys → warn.
+      def self.load(dir = Dir.pwd, warn_io: $stderr)
+        path = File.join(dir, "toy.yml")
+        unless File.file?(path)
+          c = new
+          c.instance_variable_set(:@source_path, nil)
+          return c
+        end
+        raw = YAML.safe_load(File.read(path)) || {}
+        unless raw.is_a?(Hash)
+          warn_io.puts "toy: warning: toy.yml is not a mapping; ignoring its contents"
+          raw = {}
+        end
+        raw.each_key do |k|
+          next if KNOWN_KEYS.include?(k)
+          warn_io.puts "toy: warning: unknown toy.yml key #{k.inspect} (ignored)"
+        end
+        c = new(raw.select { |k, _| KNOWN_KEYS.include?(k) })
+        c.instance_variable_set(:@source_path, path)
+        c
+      end
+
+      def to_h
+        { "run_id_template" => @run_id_template, "algos_path" => @algos_path }
+      end
+    end
+  end
+end

data/lib/toy/core/gguf_meta.rb

@@ -0,0 +1,161 @@
+# lib/toy/core/gguf_meta.rb — pure-Ruby GGUF header + kv + tensor-info reader.
+#
+# CRuby ONLY. No FFI, no ggml, no Spinel. This is the CLI shell's
+# (lib/toy/core/) means of reading model metadata WITHOUT realizing a
+# ggml session — that path (Arch.from_gguf via tnn_gguf_*) is Spinel-
+# compiled and unreachable under MRI.
+#
+# Reads:
+#   magic "GGUF" + u32 version (==3) + u64 n_tensors + u64 n_kv,
+#   the type-tagged KV section (scalars + arrays; arrays of strings are
+#   skipped past, not materialized), and the tensor-info section
+#   (name, n_dims, dims[], type, offset) for tensor-NAME presence.
+#
+# Fail-loud (memory: feedback_never_mask_fail_loud): an unknown KV type
+# tag or a bad magic raises Toy::Core::GGUFMeta::ParseError with context,
+# rather than silently returning garbage. Callers that want best-effort
+# degrade-to-unknown rescue ParseError explicitly.
+
+module Toy
+  module Core
+    # Parsed view of a GGUF file's metadata (no tensor data read).
+    #
+    #   meta = GGUFMeta.read("model.gguf")
+    #   meta.kv["llama.embedding_length"]   # => 576
+    #   meta.tensor?("output.weight")       # => false (tied)
+    class GGUFMeta
+      class ParseError < StandardError; end
+
+      # GGUF metadata value type tags (gguf.h: enum gguf_metadata_value_type).
+      T_UINT8   = 0
+      T_INT8    = 1
+      T_UINT16  = 2
+      T_INT16   = 3
+      T_UINT32  = 4
+      T_INT32   = 5
+      T_FLOAT32 = 6
+      T_BOOL    = 7
+      T_STRING  = 8
+      T_ARRAY   = 9
+      T_UINT64  = 10
+      T_INT64   = 11
+      T_FLOAT64 = 12
+
+      attr_reader :version, :n_tensors, :kv, :tensor_names
+
+      def self.read(path)
+        File.open(path, "rb") { |io| new(io, path).parse }
+      end
+
+      def initialize(io, path)
+        @io = io
+        @path = path
+        @kv = {}
+        @tensor_names = []
+      end
+
+      def parse
+        magic = read_bytes(4)
+        unless magic == "GGUF"
+          raise ParseError, "#{@path}: not a GGUF file (magic=#{magic.inspect})"
+        end
+        @version = read_u32
+        unless @version == 3
+          raise ParseError, "#{@path}: unsupported GGUF version #{@version} (only 3)"
+        end
+        @n_tensors = read_u64
+        n_kv = read_u64
+
+        n_kv.times do
+          key = read_gguf_string
+          @kv[key] = read_value
+        end
+
+        @n_tensors.times do
+          name = read_gguf_string
+          @tensor_names << name
+          n_dims = read_u32
+          n_dims.times { read_u64 }  # dims
+          read_u32                   # ggml type
+          read_u64                   # offset
+        end
+
+        self
+      end
+
+      def tensor?(name)
+        @tensor_names.include?(name)
+      end
+
+      # --- value readers -------------------------------------------------
+
+      private
+
+      def read_value
+        type = read_u32
+        read_typed(type)
+      end
+
+      def read_typed(type)
+        case type
+        when T_UINT8   then read_bytes(1).unpack1("C")
+        when T_INT8    then read_bytes(1).unpack1("c")
+        when T_UINT16  then read_bytes(2).unpack1("S<")
+        when T_INT16   then read_bytes(2).unpack1("s<")
+        when T_UINT32  then read_u32
+        when T_INT32   then read_bytes(4).unpack1("l<")
+        when T_FLOAT32 then read_bytes(4).unpack1("e")
+        when T_BOOL    then read_bytes(1).unpack1("C") != 0
+        when T_UINT64  then read_u64
+        when T_INT64   then read_bytes(8).unpack1("q<")
+        when T_FLOAT64 then read_bytes(8).unpack1("E")
+        when T_STRING  then read_gguf_string
+        when T_ARRAY   then read_array
+        else
+          raise ParseError, "#{@path}: unknown GGUF value type tag #{type}"
+        end
+      end
+
+      # Arrays: <elem_type:u32><count:u64><elems...>. For string arrays
+      # (e.g. tokenizer.ggml.tokens, ~50k entries) we only need the
+      # length, so we skip past the bytes rather than building 50k Strings.
+      def read_array
+        elem_type = read_u32
+        count = read_u64
+        if elem_type == T_STRING
+          count.times { skip_gguf_string }
+          { array: :string, length: count }
+        else
+          vals = Array.new(count) { read_typed(elem_type) }
+          { array: elem_type, length: count, values: vals }
+        end
+      end
+
+      def read_gguf_string
+        len = read_u64
+        read_bytes(len).force_encoding("UTF-8")
+      end
+
+      def skip_gguf_string
+        len = read_u64
+        @io.seek(len, IO::SEEK_CUR)
+      end
+
+      def read_u32
+        read_bytes(4).unpack1("L<")
+      end
+
+      def read_u64
+        read_bytes(8).unpack1("Q<")
+      end
+
+      def read_bytes(n)
+        buf = @io.read(n)
+        if buf.nil? || buf.bytesize < n
+          raise ParseError, "#{@path}: unexpected EOF (wanted #{n} bytes)"
+        end
+        buf
+      end
+    end
+  end
+end

data/lib/toy/core/model_scan.rb

@@ -0,0 +1,221 @@
+# lib/toy/core/model_scan.rb — find + classify GGUF models on disk.
+#
+# CRuby reimplementation of lib/model_index.rb's scan logic. The Spinel
+# library (model_index.rb) delegates dir-walking to a C shim
+# (tnn_list_ggufs) and reads arch metadata via the ggml FFI — neither is
+# reachable under MRI. This port keeps the SAME source-path order,
+# classify_path conventions, and estimate_params arithmetic, but uses
+# Dir.glob (which follows HF-cache symlinks natively) and the pure-Ruby
+# Toy::Core::GGUFMeta header reader.
+#
+# Behavior delta vs the old binary (flagged in the P3 UX contract):
+# this lists ALL *.gguf, degrading non-llama / unparseable files to
+# family=:unknown, params=0 — rather than silently dropping them.
+
+require_relative "gguf_meta"
+
+module Toy
+  module Core
+    # One discovered model. Idiomatic struct (CRuby shell; no Spinel
+    # type-pin restrictions apply here).
+    ModelEntry = Struct.new(
+      :name, :path, :family, :n_params, :size_b, :source,
+      keyword_init: true
+    ) do
+      def params_summary
+        if n_params >= 1_000_000_000
+          format("%.1fB", n_params.to_f / 1_000_000_000.0)
+        elsif n_params >= 1_000_000
+          "#{n_params / 1_000_000}M"
+        else
+          n_params.to_s
+        end
+      end
+
+      def size_summary
+        if size_b >= 1_000_000_000
+          format("%.1f GB", size_b.to_f / 1_000_000_000.0)
+        else
+          "#{size_b / 1_000_000} MB"
+        end
+      end
+    end
+
+    module ModelScan
+      module_function
+
+      # Search-path order matters for first-found dedup. Project-local
+      # paths first, then standard caches. Ported verbatim from
+      # ModelIndex.default_sources (model_index.rb:65-77).
+      def default_sources
+        home = ENV["HOME"] || "/"
+        paths = []
+        env = ENV["TOY_MODEL_DIR"]
+        paths << env if env && !env.empty?
+        paths << "./data"
+        paths << "./models"
+        paths << File.join(home, ".cache/huggingface/hub")
+        paths << File.join(home, ".ollama/models")
+        paths << File.join(home, ".lmstudio/models")
+        paths << File.join(home, "models")
+        paths
+      end
+
+      # Walk a directory tree for *.gguf files. Replaces the C shim
+      # tnn_list_ggufs with Dir.glob, which follows symlinks (HF cache
+      # stores blobs + symlinked snapshots). Returns absolute paths.
+      def find_ggufs(root)
+        return [] if root.nil? || root.empty?
+        return [] unless File.directory?(root)
+        Dir.glob(File.join(root, "**", "*.gguf"))
+           .select { |f| File.file?(f) }
+           .map { |f| File.expand_path(f) }
+      end
+
+      # Friendly name + source-kind from an absolute path. Ported from
+      # ModelIndex.classify_path (model_index.rb:108-125).
+      # Returns [source_kind, friendly_name].
+      def classify_path(path)
+        home = ENV["HOME"] || "/"
+        bn = File.basename(path)
+        bn_no_gguf = bn.end_with?(".gguf") ? bn[0...-5] : bn
+
+        if path.start_with?(File.join(home, ".cache/huggingface/hub") + "/")
+          ["hf", bn_no_gguf]
+        elsif path.start_with?(File.join(home, ".ollama/models") + "/")
+          ["ollama", bn]
+        elsif path.start_with?(File.join(home, ".lmstudio/models") + "/")
+          ["lmstudio", bn_no_gguf]
+        else
+          ["local", bn_no_gguf]
+        end
+      end
+
+      # Read arch dims + family from GGUF metadata via the pure-Ruby
+      # header reader. Mirrors the key list + family logic of
+      # Arch.from_gguf (arch.rb:159-218). Returns a Hash, or nil if the
+      # file can't be parsed as a llama-family GGUF.
+      def read_arch(meta)
+        prefix = arch_prefix(meta)
+        return nil if prefix.nil?
+
+        kv = meta.kv
+        vocab = kv["#{prefix}.vocab_size"]
+        vocab = array_length(kv["tokenizer.ggml.tokens"]) if vocab.nil?
+        d_model  = kv["#{prefix}.embedding_length"]
+        d_ff     = kv["#{prefix}.feed_forward_length"]
+        n_q      = kv["#{prefix}.attention.head_count"]
+        n_kv     = kv["#{prefix}.attention.head_count_kv"] || n_q
+        n_layers = kv["#{prefix}.block_count"]
+
+        return nil if vocab.nil? || d_model.nil? || n_layers.nil? || n_q.nil?
+        return nil if vocab <= 0 || d_model <= 0 || n_layers <= 0 || n_q <= 0
+
+        # Family detection. general.architecture reliably names genuinely
+        # different arches (gpt2, gemma2, olmoe, ...). Our own converter
+        # writes "llama" for BOTH real-llama AND real-qwen (qwen is
+        # structurally llama-family in this toy), so within "llama" we
+        # refine llama-vs-qwen2 by QKV-bias tensor presence (cosmetic —
+        # both render the same llama-family Card). Non-llama general.arch
+        # values are surfaced verbatim so `describe` can decline to render
+        # a llama Card for an arch it doesn't model (fail loud, not mask).
+        ga = kv["general.architecture"]
+        if ga.is_a?(String) && ga != "llama"
+          family = ga.to_sym
+        else
+          has_qkv_bias = meta.tensor?("blk.0.attn_q.bias") ||
+                         meta.tensor?("blk.0.attn_q.head_0.bias")
+          family = has_qkv_bias ? :qwen2 : :llama
+        end
+
+        {
+          family:   family,
+          vocab:    vocab,
+          d_model:  d_model,
+          d_ff:     d_ff,
+          n_q:      n_q,
+          n_kv:     n_kv,
+          n_layers: n_layers,
+          d_head:   d_model / n_q,
+          untied:   meta.tensor?("output.weight"),
+          ctx:      kv["#{prefix}.context_length"] || 8192,
+          rope_base: kv["#{prefix}.rope.freq_base"],
+          rms_eps:   kv["#{prefix}.attention.layer_norm_rms_epsilon"],
+          moe:       meta.tensor?("blk.0.ffn_gate_inp.weight"),
+          n_experts:      kv["#{prefix}.expert_count"] || 0,
+          n_experts_used: kv["#{prefix}.expert_used_count"] || 0,
+          arch_prefix: prefix
+        }
+      end
+
+      # Probe the arch-prefix the converter used (arch.rb:159-166).
+      def arch_prefix(meta)
+        %w[llama olmoe gemma2 qwen2 qwen3].each do |p|
+          return p if meta.kv.key?("#{p}.embedding_length")
+        end
+        # fall back to general.architecture if it names a prefix we see
+        ga = meta.kv["general.architecture"]
+        return ga if ga.is_a?(String) && meta.kv.key?("#{ga}.embedding_length")
+        nil
+      end
+
+      def array_length(v)
+        v.is_a?(Hash) ? v[:length] : nil
+      end
+
+      # Estimate parameter count from arch dims. Ported verbatim from
+      # ModelIndex.estimate_params (model_index.rb:131-144).
+      def estimate_params(a)
+        v = a[:vocab]; d = a[:d_model]; l = a[:n_layers]
+        ff = a[:d_ff] || 0
+        nq = a[:n_q]; nkv = a[:n_kv]; dh = a[:d_head]
+        embed = v * d
+        attn_per_layer = (d * nq * dh) + (d * nkv * dh) * 2 + (nq * dh * d)
+        ffn_per_layer = 3 * d * ff
+        untied = a[:untied] ? (v * d) : 0
+        embed + l * (attn_per_layer + ffn_per_layer) + untied
+      end
+
+      # Scan source dirs → [ModelEntry]. De-dup by CANONICAL (symlink-
+      # resolved) path, first-found wins — so a `toy fetch` model shows
+      # once under its data/ symlink (scanned first) rather than twice
+      # (the symlink AND the HF-cache blob it points at). Falls back to
+      # the literal path if realpath fails (e.g. a broken symlink).
+      # Unparseable/non-llama files degrade to family=:unknown, params=0
+      # (NOT dropped — the UX delta).
+      def scan(sources = default_sources)
+        seen = {}
+        out = []
+        sources.each do |src|
+          find_ggufs(src).each do |path|
+            canon = (File.realpath(path) rescue path)
+            next if seen[canon]
+            seen[canon] = true
+            src_kind, name = classify_path(path)
+            size = File.size(path)
+            entry = build_entry(path, name, src_kind, size)
+            out << entry
+          end
+        end
+        out
+      end
+
+      def build_entry(path, name, src_kind, size)
+        begin
+          meta = GGUFMeta.read(path)
+          arch = read_arch(meta)
+        rescue GGUFMeta::ParseError, SystemCallError
+          arch = nil
+        end
+        if arch
+          ModelEntry.new(name: name, path: path, family: arch[:family],
+                         n_params: estimate_params(arch), size_b: size,
+                         source: src_kind)
+        else
+          ModelEntry.new(name: name, path: path, family: :unknown,
+                         n_params: 0, size_b: size, source: src_kind)
+        end
+      end
+    end
+  end
+end

data/lib/toy/core/run_log.rb

@@ -0,0 +1,94 @@
+# lib/toy/core/run_log.rb — Toy::RunLog: read a runs/<id>/ bundle.
+#
+# CRuby-side (lib/toy/core/ — NO Spinel constraints here, idiomatic
+# Ruby is fine; do NOT require this from Spinel-compiled compute).
+# Parses runs/<id>/events.jsonl (the toy/v1 stream every trainer
+# emits) so "find my best run" is a 3-liner:
+#
+#   best = Toy::RunLog.scan("runs").first
+#   puts best.run_id
+#   puts best.final_loss
+#
+# Surface:
+#   RunLog.open(dir)  -> RunLog (fails loud when events.jsonl is
+#                        missing or carries no run_start)
+#   RunLog.scan(root) -> Array<RunLog> for every subdir with a
+#                        parseable events.jsonl, sorted by final_loss
+#                        ascending (best first; runs without a loss
+#                        sort last)
+#   #config      — the run_start event's fields (Hash; includes
+#                  "model" and "config" sub-hashes, run_id, phase, …)
+#   #steps       — the step events, in order (Array<Hash>)
+#   #loss_curve  — the per-step losses (Array<Float>)
+#   #final_loss  — run_end's final_loss, else the last step loss,
+#                  else nil (a run that never stepped)
+#   #run_id, #dir, #run_end — convenience readers
+#
+# Malformed JSONL LINES fail loud (never silently skipped — a corrupt
+# stream should be seen, not averaged over).
+
+require "json"
+
+module Toy
+  class RunLog
+    attr_reader :dir, :config, :steps, :run_end
+
+    def self.open(dir)
+      new(dir)
+    end
+
+    # Scan a runs/ root for run bundles. Subdirs without an
+    # events.jsonl are skipped (a runs/ root legitimately holds
+    # non-run dirs); a PRESENT but unparseable events.jsonl raises.
+    # Sorted by final_loss ascending; runs without a final loss last.
+    def self.scan(root)
+      raise ArgumentError, "RunLog.scan: no such directory: #{root}" unless Dir.exist?(root)
+      logs = Dir.children(root).sort.filter_map do |entry|
+        dir = File.join(root, entry)
+        next unless File.directory?(dir)
+        next unless File.file?(File.join(dir, "events.jsonl"))
+        new(dir)
+      end
+      logs.sort_by { |l| l.final_loss || Float::INFINITY }
+    end
+
+    def initialize(dir)
+      @dir    = dir
+      events  = File.join(dir, "events.jsonl")
+      raise ArgumentError, "RunLog: no events.jsonl in #{dir}" unless File.file?(events)
+
+      @config  = nil
+      @steps   = []
+      @run_end = nil
+      File.foreach(events).with_index(1) do |line, lineno|
+        next if line.strip.empty?
+        begin
+          ev = JSON.parse(line)
+        rescue JSON::ParserError => e
+          raise ArgumentError, "RunLog: #{events}:#{lineno}: malformed JSON line (#{e.message})"
+        end
+        case ev["kind"]
+        when "run_start" then @config  = ev
+        when "step"      then @steps  << ev
+        when "run_end"   then @run_end = ev
+        end
+      end
+      raise ArgumentError, "RunLog: #{events} has no run_start event" if @config.nil?
+    end
+
+    def run_id
+      @config["run_id"]
+    end
+
+    def loss_curve
+      @steps.map { |s| s["loss"] }
+    end
+
+    # run_end's final_loss when the run completed; else the last step
+    # loss (an interrupted run); else nil (a run that never stepped).
+    def final_loss
+      return @run_end["final_loss"] if @run_end && @run_end["final_loss"]
+      @steps.empty? ? nil : @steps.last["loss"]
+    end
+  end
+end

data/lib/toy/core/toy_root.rb

@@ -0,0 +1,95 @@
+# lib/toy/core/toy_root.rb — locate the toy install root + drive `make`.
+#
+# CRuby ONLY (the CLI shell). Plain MRI Ruby — NO Spinel, NO ffi_lib. This
+# is the reusable spine of the CRuby→runner compute bridge: `toy infer`
+# (and, in later slices, `toy train` / `toy serve` / `toy eval`) cannot
+# compute in-process — every lib that bears an `ffi_lib` directive crashes
+# under MRI (see cli.rb:3-8). So they must shell out to a Spinel-compiled
+# binary, and that binary must first be built. This module is the shared
+# locate-root + ensure-built half of that pattern.
+#
+# Extracted verbatim from install.rb's private locate_root /
+# toy_source_tree? so there is ONE resolver, no drift. install.rb now
+# delegates here.
+#
+# Root-location priority (same as install.rb's documented order):
+#   1. ENV["TOY_HOME"]                 — explicit override
+#   2. dev checkout discovered by walking up from __dir__ (max 20 levels)
+#   3. Gem.loaded_specs["toy"].gem_dir — gem-installed root (if present)
+#
+# Source-tree sentinel: Makefile + tinynn/tinynn_ggml.c. The C shim source
+# is the definitive marker — it ships in the source tree and is never a
+# build artifact (unlike vendor/ggml/, which only exists after `make
+# setup`).
+
+require "open3"
+
+module Toy
+  module Core
+    module ToyRoot
+      module_function
+
+      # Priority: TOY_HOME → dev-checkout walk-up → gem dir. All three are
+      # validated with the same #source_tree? sentinel so they stay in sync
+      # — a stale TOY_HOME or empty gem dir fails the same way as a non-toy
+      # walk-up hit instead of silently returning garbage. Returns the
+      # absolute root path, or nil if none resolves.
+      def locate_root
+        env = ENV["TOY_HOME"]
+        if env && !env.empty?
+          expanded = File.expand_path(env)
+          return expanded if source_tree?(expanded)
+        end
+
+        dir = __dir__
+        20.times do
+          return dir if source_tree?(dir)
+          parent = File.dirname(dir)
+          break if parent == dir
+          dir = parent
+        end
+
+        if defined?(Gem) && Gem.loaded_specs["toy"]
+          gd = Gem.loaded_specs["toy"].gem_dir
+          return gd if gd && source_tree?(gd)
+        end
+        nil
+      end
+
+      # Sentinel test: does `dir` look like a toy source tree we can run
+      # `make` in? Requires the Makefile plus a source-only marker
+      # (tinynn_ggml.c) that is always shipped and is never a build
+      # artifact. vendor/ggml/ is NOT a valid sentinel — setup CREATES it,
+      # so a bone-fresh clone fails it.
+      def source_tree?(dir)
+        File.file?(File.join(dir, "Makefile")) &&
+          File.file?(File.join(dir, "tinynn", "tinynn_ggml.c"))
+      end
+
+      # Build `target` (a Makefile target, e.g. "libexec/toy-infer")
+      # in `root` via `make`. Idempotent — make no-ops when the target is
+      # up-to-date, so callers may invoke this unconditionally rather than
+      # reimplement mtime staleness. The first build on a fresh tree can
+      # take minutes (the target deps pull the full lib inference stack), so
+      # echo a notice unless `quiet`.
+      #
+      # Build progress (the notice + make's own output) goes to $stderr so
+      # that callers which parse the runner's $stdout (e.g. `toy infer`) get
+      # a clean compute stream uncontaminated by build chatter. Returns
+      # [true, nil] on success, or [false, message] with a clean one-line
+      # failure (last 20 lines of make output) — never raises, so callers
+      # can fail loud with their own command prefix.
+      def ensure_built(root, target, quiet: false)
+        $stderr.puts "building #{target} in #{root} (this may take a few minutes)..." unless quiet
+        out, status = Open3.capture2e("make", "-C", root, target)
+        if status.success?
+          $stderr.print out unless quiet
+          [true, nil]
+        else
+          tail = out.lines.last(20).join
+          [false, "`make #{target}` failed in #{root}:\n#{tail}"]
+        end
+      end
+    end
+  end
+end