def handle_numeric(right)
      return right if (right.fits_u8?)  # no shifting needed
      if (op_with_rot = calculate_u8_with_rr(right))
        return op_with_rot
      end
      unless @extra
        # puts "RELINK L at #{Risc::Position.get(self)}"
        # use sub for sub and add for add, ie same as opcode
        insert ArmMachine.send( opcode ,  result , result , 0 ) #noop
        @extra = @next
      end
      shift = 0xFF
      operand = nil
      until( operand )
        mask = 0xFFFFFFFF ^ shift
        # now we can do the actual breaking of instruction, by splitting the operand
        operand = calculate_u8_with_rr( right & mask )
        @next.set_value(right & shift )
        raise "internal #{shift} for #{self}" if shift > 0xFFFFFF
        shift = (shift << 8) + 0xFF
      end
      return operand
    end
def handle_numeric(right)
      return right if (right.fits_u8?)  # no shifting needed
      if (op_with_rot = calculate_u8_with_rr(right))
        return op_with_rot
      end
      unless @extra
        # puts "RELINK L at #{Risc::Position.get(self)}"
        # use sub for sub and add for add, ie same as opcode
        insert ArmMachine.send( opcode ,  result , result , 0 ) #noop
        @extra = @next
      end
      shift = 0xFF
      operand = nil
      until( operand )
        mask = 0xFFFFFFFF ^ shift
        # now we can do the actual breaking of instruction, by splitting the operand
        operand = calculate_u8_with_rr( right & mask )
        @next.set_value(right & shift )
        raise "internal #{shift} for #{self}" if shift > 0xFFFFFF
        shift = (shift << 8) + 0xFF
      end
      return operand
    end
Arm can't load any large (over 1024) numbers, or larger with fancy shifting,
 but then the lower bits must be 0's. Especially in constant loading random large numbers
 happen, and so they are split into two instructions. An exeption is thrown, that triggers
 some position handling and an @extra add instruction generated.