origen_testers 0.4.0

data/lib/origen_testers/test/j750_hpt_interface.rb

@@ -0,0 +1,8 @@
+require 'origen_testers/test/j750_base_interface'
+module OrigenTesters
+  module Test
+    class J750HPTInterface < J750BaseInterface
+      include OrigenTesters::J750_HPT::Generator
+    end
+  end
+end

data/lib/origen_testers/test/j750_interface.rb

@@ -0,0 +1,8 @@
+require 'origen_testers/test/j750_base_interface'
+module OrigenTesters
+  module Test
+    class J750Interface < J750BaseInterface
+      include OrigenTesters::J750::Generator
+    end
+  end
+end

data/lib/origen_testers/test/nvm.rb

@@ -0,0 +1,94 @@
+module OrigenTesters
+  module Test
+    class NVM
+      attr_accessor :blocks
+
+      include Origen::Pins
+      include Origen::Registers
+
+      def initialize
+        add_reg :mclkdiv,   0x03,  16,  osch:    { pos: 15 },
+                                        asel:    { pos: 14 },
+                                        failctl: { pos: 13 },
+                                        parsel:  { pos: 12 },
+                                        eccen:   { pos: 11 },
+                                        cmdloc:  { pos: 8, bits: 3, res: 0b001 },
+                                        clkdiv:  { pos: 0, bits: 8, res: 0x18 }
+
+        add_reg :data,      0x4,   16,  d: { pos: 0, bits: 16 }
+
+        @blocks = [Block.new(0, self), Block.new(1, self), Block.new(2, self)]
+      end
+
+      def find_block_by_id(id)
+        @blocks.find { |block| block.id == id }
+      end
+
+      def reg_owner_alias
+        %w(flash fmu)
+      end
+
+      def override_method
+        :overridden
+      end
+
+      def added_method
+        :added
+      end
+
+      def add_proth_reg
+        reg :proth, 0x0024, size: 32 do
+          bits 31..24,   :fprot7,  reset: 0xFF
+          bits 23..16,   :fprot6,  reset: 0xEE
+          bits 15..8,    :fprot5,  reset: 0xDD
+          bits 7..0,     :fprot4,  reset: 0x11
+        end
+      end
+    end
+
+    class NVMSub < NVM
+      def redefine_data_reg
+        add_reg :data,      0x40,   16,  d: { pos: 0, bits: 16 }
+      end
+
+      # Tests that the block format for defining registers works
+      def add_reg_with_block_format
+        # ** Data Register 3 **
+        # This is dreg
+        add_reg :dreg, 0x1000, size: 16 do
+          # This is dreg bit 15
+          bit 15,    :bit15, reset: 1
+          # **Bit 14** - This does something cool
+          #
+          # 0 | Coolness is disabled
+          # 1 | Coolness is enabled
+          bits 14,    :bit14
+          # This is dreg bit upper
+          bits 13..8, :upper
+          # This is dreg bit lower
+          # This is dreg bit lower line 2
+          bit 7..0,  :lower, writable: false, reset: 0x55
+        end
+
+        # This is dreg2
+        reg :dreg2, 0x1000, size: 16 do
+          # This is dreg2 bit 15
+          bit 15,    :bit15, reset: 1
+          # This is dreg2 bit upper
+          bits 14..8, :upper
+          # This is dreg2 bit lower
+          # This is dreg2 bit lower line 2
+          bit 7..0,  :lower, writable: false, reset: 0x55
+        end
+
+        # Finally a test that descriptions can be supplied via the API
+        reg :dreg3, 0x1000, size: 16, description: "** Data Register 3 **\nThis is dreg3" do
+          bit 15,    :bit15, reset: 1, description: 'This is dreg3 bit 15'
+          bit 14, :bit14, description: "**Bit 14** - This does something cool\n\n0 | Coolness is disabled\n1 | Coolness is enabled"
+          bits 13..8, :upper, description: 'This is dreg3 bit upper'
+          bit 7..0,  :lower, writable: false, reset: 0x55, description: "This is dreg3 bit lower\nThis is dreg3 bit lower line 2"
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/test/ultraflex_interface.rb

@@ -0,0 +1,110 @@
+module OrigenTesters
+  module Test
+    class UltraFLEXInterface
+      include OrigenTesters::UltraFLEX::Generator
+
+      # Options passed to Flow.create and Library.create will be passed in here, use as
+      # desired to configure your interface
+      def initialize(options = {})
+      end
+
+      def log(msg)
+        flow.logprint(msg)
+      end
+
+      def func(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        block_loop(name, options) do |block, i, group|
+          ins = test_instances.functional(name)
+          ins.set_wait_flags(:a) if options[:duration] == :dynamic
+          ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
+          if group
+            pname = "#{name}_b#{i}_pset"
+            patsets.add(pname, [{ pattern: "#{name}_b#{i}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            flow.test(group, options) if i == 0
+          else
+            pname = "#{name}_pset"
+            patsets.add(pname, [{ pattern: "#{name}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            if options[:cz_setup]
+              flow.cz(ins, options[:cz_setup], options)
+            else
+              flow.test(ins, options)
+            end
+          end
+        end
+      end
+
+      def meas(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        name = "meas_#{name}" unless name.to_s =~ /meas/
+
+        ins = test_instances.functional(name)
+        ins.set_wait_flags(:a) if options[:duration] == :dynamic
+        ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
+
+        pname = "#{name}_pset"
+        patsets.add(pname, [{ pattern: "#{name}.PAT" },
+                            { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+        ins.pattern = pname
+        if options[:cz_setup]
+          flow.cz(ins, options[:cz_setup], options)
+        else
+          use_limit_params = [:lo_limit, :hi_limit, :scale, :units] # define options to strip for flow.test
+          options_use_limit = options.dup                           # duplicate, as modifying options directly, even an assigned copy modifies original
+          flow.test(ins, options.reject! { |k, _| use_limit_params.include? k })    # set up test skipping use-limit options
+          flow.use_limit(name, options_use_limit) if options_use_limit[:hi_limit] || options_use_limit[:lo_limit]  # Only use use-limit if limits present in flow
+        end
+      end
+
+      def block_loop(name, options)
+        if options[:by_block]
+          test_instances.group do |group|
+            group.name = name
+            $dut.blocks.each_with_index do |block, i|
+              yield block, i, group
+            end
+          end
+        else
+          yield
+        end
+      end
+
+      def por(options = {})
+        options = {
+          instance_not_available: true
+        }.merge(options)
+        flow.test('por_ins', options)
+      end
+
+      def para(name, options = {})
+        print "UltraFLEX Parametric Test not yet supported for UltraFlex!\n"
+      end
+
+      # OR 2 IDS together into 1 flag
+      def or_ids(options = {})
+        flow.or_flags(options[:id1], options[:id2], options)
+      end
+
+      def nop(options = {})
+        flow.nop options
+      end
+
+      def mto_memory(args)
+        # DO NOTHING, NOT YET SUPPORTED IN ULTRAFLEX
+      end
+
+      def bin(number, options = {})
+      end
+    end
+  end
+end

data/lib/origen_testers/test/v93k_interface.rb

@@ -0,0 +1,115 @@
+module OrigenTesters
+  module Test
+    class V93KInterface
+      include OrigenTesters::V93K::Generator
+
+      # Options passed to Flow.create and Library.create will be passed in here, use as
+      # desired to configure your interface
+      def initialize(options = {})
+      end
+
+      def log(msg)
+        flow.print_to_datalog(msg)
+      end
+
+      def func(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        block_loop(name, options) do |block, i, group|
+          tm = test_methods.ac_tml.ac_test.functional_test
+          ts = test_suites.run(name, options)
+          ts.test_method = tm
+          ts.levels = options.delete(:pin_levels) if options[:pin_levels]
+          if group
+            ts.pattern = "#{name}_b#{i}"
+          else
+            ts.pattern = name.to_s
+            #    if options[:cz_setup]
+            #      flow.cz(ins, options[:cz_setup], options)
+            #    else
+            #    end
+          end
+          flow.test ts, options
+        end
+      end
+
+      def meas(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        name = "meas_#{name}" unless name.to_s =~ /meas/
+
+        tm = test_methods.dc_tml.dc_test.general_pmu
+        ts = test_suites.run(name, options)
+        ts.test_method = tm
+        ts.levels = options.delete(:pin_levels) if options[:pin_levels]
+        ts.lo_limit = options[:lo_limit] if options[:lo_limit]
+        ts.hi_limit = options[:hi_limit] if options[:hi_limit]
+        ts.pattern = name.to_s
+        # if options[:cz_setup]
+        #  flow.cz(ins, options[:cz_setup], options)
+        # else
+        #  use_limit_params = [:lo_limit, :hi_limit, :scale, :units] # define options to strip for flow.test
+        #  options_use_limit = options.dup                           # duplicate, as modifying options directly, even an assigned copy modifies original
+        #  flow.test(ins, options.reject! { |k, _| use_limit_params.include? k })    # set up test skipping use-limit options
+        #  flow.use_limit(name, options_use_limit) if options_use_limit[:hi_limit] || options_use_limit[:lo_limit]  # Only use use-limit if limits present in flow
+        # end
+        flow.test ts, options
+      end
+
+      def group(name, options = {})
+        flow.group name, options do |group|
+          yield group
+        end
+      end
+
+      def block_loop(name, options)
+        if options[:by_block]
+          flow.group name, options do |group|
+            $dut.blocks.each_with_index do |block, i|
+              yield block, i, group
+            end
+          end
+        else
+          yield
+        end
+      end
+
+      def por(options = {})
+        options = {
+          instance_not_available: true
+        }.merge(options)
+        func('por_ins', options)
+      end
+
+      def para(name, options = {})
+        # print "UltraFLEX Parametric Test not yet supported for UltraFLEX!\n"
+      end
+
+      # OR 2 IDS together into 1 flag
+      # def or_ids(options = {})
+      #  flow.or_flags(options[:id1], options[:id2], options)
+      # end
+
+      def nop(options = {})
+        # flow.nop options
+      end
+
+      def mto_memory(name, options = {})
+        # Seriously?!
+      end
+
+      # OR 2 IDS together into 1 flag
+      def or_ids(options = {})
+        # Eh?
+      end
+
+      def bin(number, options = {})
+        flow.good_bin(number, bin_desc: options[:description])
+      end
+    end
+  end
+end

data/lib/origen_testers/timing.rb

@@ -0,0 +1,362 @@
+module OrigenTesters
+  module Timing
+    extend ActiveSupport::Concern
+
+    included do
+      # When set to true all pattern vectors will be converted to use the same period (the
+      # shortest period used in the pattern).
+      #
+      # @example
+      #   $tester.set_timeset("fast", 40)
+      #   2.cycles                        #    fast   1 0 0 1 0
+      #                                   #    fast   1 0 0 1 0
+      #
+      #   $tester.level_period = false  # Without levelling enabled
+      #   $tester.set_timeset("slow", 80)
+      #   2.cycles                        #    slow   1 0 0 1 0
+      #                                   #    slow   1 0 0 1 0
+      #
+      #   $tester.level_period = true   # With levelling enabled
+      #   $tester.set_timeset("slow", 80)
+      #   2.cycles                        #    fast   1 0 0 1 0
+      #                                   #    fast   1 0 0 1 0
+      #                                   #    fast   1 0 0 1 0
+      #                                   #    fast   1 0 0 1 0
+      #
+      # @see Timing#timing_toggled_pins
+      attr_accessor :level_period
+      alias_method :level_period?, :level_period
+      attr_writer :timing_toggled_pins
+    end
+
+    class Timeset
+      attr_accessor :name, :period_in_ns
+
+      def initialize(attrs = {})
+        attrs.each do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      # Returns true if the timeset has a shorter period than the supplied timeset
+      def shorter_period_than?(timeset)
+        period_in_ns < timeset.period_in_ns
+      end
+    end
+
+    # @see Timing#level_period
+    #
+    # When period levelling is enabled, vectors will be expanded like this:
+    #   $tester.set_timeset("fast", 40)
+    #   2.cycles                        #    fast   1 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #   # Without levelling enabled
+    #   $tester.set_timeset("slow", 80)
+    #   2.cycles                        #    slow   1 0 0 1 0
+    #                                   #    slow   1 0 0 1 0
+    #   # With levelling enabled
+    #   $tester.set_timeset("slow", 80)
+    #   2.cycles                        #    fast   1 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #
+    # The overall time of the levelled/expanded vectors matches that of the unlevelled
+    # case. i.e. 4 cycles at fast speed (4 * 40ns = 160ns) is equivalent to 2 cycles
+    # at slow speed (2 * 80ns = 160ns).
+    #
+    # However, what if pin 1 in the example above was a clk pin where the 1 -> 0 transition
+    # was handled by the timing setup for that pin.
+    # In that case the levelled code is no longer functionally correct since it contains
+    # 4 clock pulses while the unlevelled code only has 2.
+    #
+    # Such pins can be specified via this attribute and the levelling logic will then
+    # automatically adjust the drive state to keep the number of pulses correct.
+    # It would automatically adjust to the alternative logic state where 0 means 'on'
+    # and 1 means 'off' if applicable.
+    #
+    #   $tester.timing_toggled_pins << $dut.pin(:tclk)  # This is pin 1
+    #
+    #   $tester.set_timeset("fast", 40)
+    #   2.cycles                        #    fast   1 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #   # Without levelling enabled
+    #   $tester.set_timeset("slow", 80)
+    #   2.cycles                        #    slow   1 0 0 1 0
+    #                                   #    slow   1 0 0 1 0
+    #   # With levelling enabled
+    #   $tester.set_timeset("slow", 80)
+    #   2.cycles                        #    fast   1 0 0 1 0
+    #                                   #    fast   0 0 0 1 0
+    #                                   #    fast   1 0 0 1 0
+    #                                   #    fast   0 0 0 1 0
+    #
+    # Multiple pins an be specified like this:
+    #   $tester.timing_toggled_pins = [$dut.pin(:tclk), $dut.pin(:clk)]   # Overrides any pins added elsewhere
+    #   $tester.timing_toggled_pins << [$dut.pin(:tclk), $dut.pin(:clk)]  # In addition to any pins added elsewhere
+    def timing_toggled_pins
+      @timing_toggled_pins ||= []
+      @timing_toggled_pins.flatten!
+      @timing_toggled_pins
+    end
+
+    # Set the timeset for the next vectors, this will remain in place until the next
+    # time this is called.
+    #
+    #   $tester.set_timeset("bist_25mhz", 40)
+    #
+    # This method also accepts a block in which case the contained vectors will generate
+    # with the supplied timeset and subsequent vectors will return to the previous timeset
+    # automatically.
+    #
+    #   $tester.set_timeset("bist_25mhz", 40) do
+    #     $tester.cycle
+    #   end
+    #
+    # The arguments can also be supplied as a single array, or not at all. In the latter case
+    # the existing timeset will simply be preserved. This is useful if you have timesets that
+    # can be conditionally set based on the target.
+    #
+    #   # Target 1
+    #   $soc.readout_timeset = ["readout", 120]
+    #   # Target 2
+    #   $soc.readout_timeset = false
+    #
+    #   # This code is compatible with both targets, in the first case the timeset will switch
+    #   # over, in the second case the existing timeset will be preserved.
+    #   $tester.set_timeset($soc.readout_timeset) do
+    #     $tester.cycle
+    #   end
+    def set_timeset(timeset, period_in_ns = nil)
+      if timeset.is_a?(Array)
+        timeset, period_in_ns = timeset[0], timeset[1]
+      end
+      timeset ||= @timeset
+      unless timeset.is_a?(Timeset)
+        fail 'You must supply a period_in_ns argument to set_timeset' unless period_in_ns
+        timeset = Timeset.new(name: timeset.to_s.chomp, period_in_ns: period_in_ns)
+      end
+      called_timesets << timeset unless called_timesets.map(&:name).include?(timeset.name)
+      if @min_period_timeset
+        @min_period_timeset = timeset if timeset.shorter_period_than?(@min_period_timeset)
+      else
+        @min_period_timeset = timeset
+      end
+      if block_given?
+        original = @timeset
+        timeset_changed(timeset)
+        @timeset = timeset
+        yield
+        timeset_changed(original)
+        @timeset = original
+      else
+        timeset_changed(timeset)
+        @timeset = timeset
+      end
+    end
+
+    # Returns the timeset (a Timeset object) with the shortest period that has been
+    # encountered so far in the course of generating the current pattern.
+    #
+    # A tester object is re-instantiated at the start of every pattern which will reset
+    # this variable.
+    def min_period_timeset
+      @min_period_timeset
+    end
+
+    def timeset_changed(timeset)
+      if last_vector && last_vector.timeset != timeset
+        change = { old: last_vector.timeset, new: timeset }
+        # Suppress any duplicate calls
+        if !@_last_timeset_change ||
+           (@_last_timeset_change[:new] != change[:new] &&
+             @_last_timeset_change[:old] != change[:old])
+          before_timeset_change(change)
+        end
+        @_last_timeset_change = change
+      end
+    end
+
+    def before_timeset_change(options = {})
+    end
+
+    # Cause the pattern to wait.
+    # The following options are available to help you specify the time to wait:
+    # * :cycles - delays specified in raw cycles, the test model is responsible for translating this into a sequence of valid repeat statements
+    # * :time_in_ns - time specified in nano-seconds
+    # * :time_in_us - time specified in micro-seconds
+    # * :time_in_ms - time specified in milli-seconds
+    # * :time_in_s - time specified in seconds
+    # If more than one option is supplied they will get added together to give a final
+    # delay time expressed in cycles.
+    # ==== Examples
+    #   $tester.wait(cycles: 100, time_in_ns: 200)   # Wait for 100 cycles + 200ns
+    # This method can also be used to trigger a match loop in which case the supplied time
+    # becomes the time out for the match. See the J750#match method for full details of the
+    # available options.
+    #   $tester.wait(match: true, state: :high, pin: $dut.pin(:done), time_in_ms: 500)
+    def wait(options = {})
+      options = {
+        cycles:         0,
+        time_in_cycles: 0,
+        time_in_us:     0,
+        time_in_ns:     0,
+        time_in_ms:     0,
+        time_in_s:      0,
+        match:          false,   # Set to true to invoke a match loop where the supplied delay
+        # will become the timeout duration
+      }.merge(options)
+
+      cycles = 0
+      cycles += options[:cycles] + options[:time_in_cycles]
+      cycles += s_to_cycles(options[:time_in_s])
+      cycles += ms_to_cycles(options[:time_in_ms])
+      cycles += us_to_cycles(options[:time_in_us])
+      cycles += ns_to_cycles(options[:time_in_ns])
+
+      time = cycles * current_period_in_ns   # Total delay in ns
+      case
+        when time < 1000                      # When less than 1us
+          cc "Wait for #{'a maximum of ' if options[:match]}#{time}ns"
+        when time < 1_000_000                   # When less than 1ms
+          cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1000).round(1)}us"        # Display delay in us
+        when time < 1_000_000_000                # When less than 1s
+          cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1_000_000).round(1)}ms"
+        else
+          cc "Wait for #{'a maximum of ' if options[:match]}%.2fs" % (time.to_f / 1_000_000_000)
+      end
+
+      if cycles > 0   # Allow this function to be called with 0 in which case it will just return
+        if options[:match]
+          if block_given?
+            match_block(cycles, options) { yield }
+          else
+            match(options[:pin], options[:state], cycles, options)
+          end
+        else
+          delay(cycles)
+        end
+      end
+    end
+
+    # @see Timing#wait
+    # @api private
+    # This should not be called directly, call via tester#wait
+    def delay(cycles, options = {})
+      (cycles / max_repeat_loop).times do
+        if block_given?
+          yield options.merge(repeat: max_repeat_loop)
+        else
+          cycle(options.merge(repeat: max_repeat_loop))
+        end
+      end
+      if block_given?
+        yield options.merge(repeat: (cycles % max_repeat_loop))
+      else
+        cycle(options.merge(repeat: (cycles % max_repeat_loop)))
+      end
+    end
+
+    def max_repeat_loop
+      @max_repeat_loop || 65_535
+    end
+
+    def min_repeat_loop
+      @min_repeat_loop
+    end
+
+    def called_timesets
+      @called_timesets ||= []
+    end
+
+    def current_period_in_ns
+      if @timeset
+        @timeset.period_in_ns
+      else
+        fail 'No timeset has been specified yet!'
+      end
+    end
+    alias_method :current_period, :current_period_in_ns
+    alias_method :period, :current_period_in_ns
+
+    def current_timeset
+      @timeset
+    end
+    alias_method :timeset, :current_timeset
+
+    # Convert the supplied number of cycles to a time, based on the SoC defined cycle period
+    def cycles_to_time(cycles) # :nodoc:
+      (cycles * current_period_in_ns).to_f / 1_000_000_000
+    end
+
+    # This function can be used to generate a clock or some other repeating function
+    # that spans accross a range of vectors.
+    # The period of each cycle and the duration of the sequence are supplied via the following
+    # options:
+    # * :period_in_cycles
+    # * :period_in_ns
+    # * :period_in_us
+    # * :period_in_ms
+    # * :duration_in_cycles
+    # * :duration_in_ns
+    # * :duration_in_us
+    # * :duration_in_ms
+    # If multiple definitions for either option are supplied then they will be added
+    # together.
+    # ==== Example
+    #   # Supply a clock pulse on :pinA for 100ms
+    #   $tester.count(:period_in_cycles => 10, :duration_in_ms => 100) do
+    #       $top.pin(:pinA).drive!(1)
+    #       $top.pin(:pinA).drive!(0)
+    #   end
+    def count(options = {})
+      options = { period_in_cycles: 0, period_in_ms: 0, period_in_us: 0, period_in_ns: 0,
+                  duration_in_cycles: 0, duration_in_ms: 0, duration_in_us: 0, duration_in_ns: 0
+                }.merge(options)
+
+      period_cycles = options[:period_in_cycles] + ms_to_cycles(options[:period_in_ms]) +
+                      us_to_cycles(options[:period_in_us]) + ns_to_cycles(options[:period_in_ns])
+
+      duration_cycles = options[:duration_in_cycles] + ms_to_cycles(options[:duration_in_ms]) +
+                        us_to_cycles(options[:duration_in_us]) + ns_to_cycles(options[:duration_in_ns])
+
+      total = 0
+      while total < duration_cycles
+        wait(time_in_cycles: period_cycles)
+        yield								# Return control back to caller
+        total += period_cycles
+      end
+    end
+
+    private
+
+    def s_to_cycles(time) # :nodoc:
+      ((time.to_f) * 1000 * 1000 * 1000 / current_period_in_ns).to_int
+    end
+
+    def ms_to_cycles(time) # :nodoc:
+      ((time.to_f) * 1000 * 1000 / current_period_in_ns).to_int
+    end
+
+    def us_to_cycles(time) # :nodoc:
+      ((time.to_f * 1000) / current_period_in_ns).to_int
+    end
+
+    def ns_to_cycles(time) # :nodoc:
+      (time.to_f / current_period_in_ns).to_int
+    end
+
+    def cycles_to_us(cycles) # :nodoc:
+      ((cycles.to_f * current_period_in_ns) / (1000)).ceil
+    end
+
+    def cycles_to_ms(cycles) # :nodoc:
+      ((cycles.to_f * current_period_in_ns) / (1000 * 1000)).ceil
+    end
+
+    # Cycles to tenths of a second
+    def cycles_to_ts(cycles) # :nodoc:
+      ((cycles.to_f * current_period_in_ns) / (1000 * 1000 * 100)).ceil
+    end
+  end
+end