CHIRP

                for tone in tones:

                    assert tone in chirp_common.TONES, (

                        "tone %s not one of %s" % (tone, chirp_common.TONES))

            raise ValueError("%s %s: %s" % (name, limits, e))

        self.name = name

            pp(i, level+2)

        elif isinstance(i, tuple):

            if isinstance(i[1], str):

            else:

                pp(i, level+2)

        elif isinstance(i, str):

def array_copy(dst, src):

def int_to_bcd(bcd_array, value):

    """Convert an int like 1234 into bcdDataElements like "\x12\x34" """

        bcd_array[i].set_value(value % 100)

        value /= 100

    def __set_value_bbcd(self, value):

        for i in reversed(self.__items):

            twodigits = value % 100

            i.set_value(twodigits)

    def __set_value_lbcd(self, value):

        for i in self.__items:

            twodigits = value % 100

            i.set_value(twodigits)

    def __set_value_char(self, value):

    def __mul__(self, val):

        return self.get_value() * val

        return self.get_value() / val

    def __add__(self, val):

        return self.get_value() + val

    def __rmul__(self, val):

        return val * self.get_value()

        return val / self.get_value()

    def __rand__(self, val):

        return val & self.get_value()

        self.set_value(self.get_value() * val)

        return self

        self.set_value(self.get_value() / val)

        return self

    def __imod__(self, val):

        self.set_value(self.get_value() % val)

        return self

    def __ge__(self, val):

        return self.get_value() >= val

        return self.get_value() != 0

            s += "  %15s: %s%s" % (prop, repr(self._generators[prop]),

                                   os.linesep)

        s += "} %s (%i bytes at 0x%04X)%s" % (self._name,

                                              self._offset,

                                              os.linesep)

        return s

        self._generators = {}

        self._keys = []

        self._count = 1

            self._name = kwargs["name"]

            del kwargs["name"]

        else:

        return size

    def get_raw(self):

        return self._data[self._offset:self._offset+size]

    def set_raw(self, buffer):

            raise ValueError("Struct size mismatch during set_raw()")

        self._data[self._offset] = buffer

        self._generators[name] = gen

    def do_bitfield(self, dtype, bitfield):

        bitsleft = bytes * 8

        for _bitdef, defn in bitfield:

                    self._offset += int((i+1) % 8 == 0)

                else:

                    gen = self._types[dtype](self._data, self._offset)

                res.append(gen)

            if count == 1:

    data = "\xab\x7F\x81abc\x12\x34"

    tree = parse(defn, data)

                                                    tree.mystruct.sixzeros,

    import sys

    sys.exit(0)

    # Mess with it a little

    p = Processor(data, 0)

    obj = p.parse(ast)

    obj["foo"][0]["bar"].set_value(255 << 8)

    obj["foo"][0]["twobit"].set_value(0)

    obj["foo"][0]["onebit"].set_value(1)

    for i in obj["foo"][0]["array"]:

    obj["foo"][0]["array"][1].set_value(255)

    for i in obj["foo"][0]["bcdL"]:

    int_to_bcd(obj["foo"][0]["bcdL"], 1234)

    set_string(obj["foo"][0]["str"], "xyz")

        def __iter__(self):

            return self

            self.line += 1

            try:

                # Note, FileInput objects keep the newlines

import json

import logging

import math

from chirp import errors, memmap, CHIRP_VERSION

LOG = logging.getLogger(__name__)

    def __gt__(self, val):

        return int(self) > int(val)

        return int(self) != 0

    def __repr__(self):

def format_freq(freq):

    """Format a frequency given in Hz as a string"""

class ImmutableValueError(ValueError):

        if name.startswith("_"):

            self.__dict__[name] = val

            return

            raise ValueError("No such attribute `%s'" % name)

        if type(self._valid_map[name]) == tuple:

    def is_a_feature(self, name):

        """Returns True if @name is a valid feature flag name"""

    def __getitem__(self, name):

        return self.__dict__[name]

                    msg = ValidationError("Frequency requires %.2fkHz step" %

                                          required_step(mem.freq))

                    msgs.append(msg)

                msgs.append(str(e))

        if self.valid_characters:

    def load_mmap(self, filename):

        """Load the radio's memory map from @filename"""

        data = mapfile.read()

        if self.MAGIC in data:

            data, self._metadata = self._strip_metadata(data)

        If IOError raise a File Access Error Exception

        """

        try:

            mapfile.write(self._mmap.get_packed())

            if filename.lower().endswith(".img"):

                mapfile.write(self.MAGIC)

    def __str__(self):

        try:

            pct = (self.cur / float(self.max)) * 100

            ticks = "=" * nticks

        except ValueError:

            pct = 0.0

    else:

        raise errors.InvalidDataError("Unable to calculate the required " +

                                      "tuning step for %i.%5i" %

def fix_rounded_step(freq):

    myfilter = ''.join(

        [

            [replacechar, chr(x)][chr(x) in validcharset]

        ])

    return astring.translate(myfilter)

        ser.baudrate = 9600

        md = icf.get_model_data(ser)

        return _icom_model_data_to_rclass(md)

        LOG.error("_detect_icom_radio: %s", e)

    # ICOM IC-91/92 Live-mode radios @ 4800/38400 baud

        if rclass.VENDOR == "Kenwood":

            models[rclass.MODEL] = rclass

        return models[r_id]

    else:

        raise errors.RadioError("Unsupported model `%s'" % r_id)

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import tempfile

import logging

    """Register radio @cls with the directory"""

    global DRV_TO_RADIO

    ident = radio_class_id(cls)

        if ALLOW_DUPS:

            LOG.warn("Replacing existing driver id `%s'" % ident)

        else:

            pass  # Skip non-Icoms

    if img_data:

        f.write(img_data)

        f.close()

    else:

        image_file = tempf

    if os.path.exists(image_file):

        filedata = f.read()

        f.close()

    else:

import json

import logging

import tempfile

from chirp import chirp_common, errors

from chirp.settings import RadioSetting, RadioSettingGroup, \

     RadioSettingValueList

    def do_fetch(self):

        fn = tempfile.mktemp(".json")

        with open(fn, 'r') as f:

            try:

                self._repeaters = json.load(f)['repeaters']

        rs = RadioSetting(

            "color_code", "Color Code", RadioSettingValueList(

        mem.extra.append(rs)

        return mem

            self._mmap = self._download(self._memsize)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            self._upload(self._memsize)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def get_raw_memory(self, number):

        return rf

    def _get_used(self, number):

        bit = (0x80 >> (number % 8))

        return _usd & bit

    def _set_used(self, number, is_used):

        bit = (0x80 >> (number % 8))

        if is_used:

            _usd |= bit

    def get_memory(self, number):

        _mem = self._memobj.memory[number]

        bit = (0x80 >> (number % 8))

        mem = chirp_common.Memory()

    def set_memory(self, mem):

        _mem = self._memobj.memory[mem.number]

        bit = (0x80 >> (mem.number % 8))

        if self._get_used(mem.number) and not mem.empty:

        # Get a low-level memory object mapped to the image

        _mem = self._memobj.memory[mem.number]

        if mem.empty:

            _mem.empty = 0x00

        else:

            _mem.empty = self._get_empty_flag(mem.freq, mem.mode)

def _is_loc_used(memobj, loc):

def _addr_to_loc(addr):

def _should_send_addr(memobj, addr):

    try:

        radio.pipe.write(data)

        radio.pipe.read(len(data))

        LOG.error("Error writing to radio: %s" % e)

        raise errors.RadioError("Unable to write to radio")

def _read(radio, length):

    try:

        data = radio.pipe.read(length)

        LOG.error("Error reading from radio: %s" % e)

        raise errors.RadioError("Unable to read from radio")

    def _get_memobjs(self, number):

        number -= 1

        _mem = self._memobj.memory[number]

                       number % 2 and "even" or "odd")

        return _mem, _flg

        rs = RadioSetting("welcome", "Welcome Message",

                          RadioSettingValueString(0, 8,

        basic.append(rs)

        rs = RadioSetting("beep", "Beep Enabled",

mem_format = """

struct memory {

  bbcd freq[4];

     tune_step:4;

     txdcsextra:1,

     txinv:1,

     channel_width:2,

     unknown3:1,

     tx_off:1;

     rxdcsextra:1,

     rxinv:1,

     power:2,

     duplex:2;

     rxtmode:2,

     txtmode:2;

     txtone:6;

     rxtone:6;

     unknown9:2,

     bcl:2;

     sqlmode:1;

  u8 unknownC[4];

};

#seekto 0x0010;

struct {

    u8 unknown1;

       bands1:3;

       bands2:3;

    char seller[16];

} oem_info;

def _echo_write(radio, data):

    try:

        radio.pipe.write(data)

        LOG.error("Error writing to radio: %s" % e)

        raise errors.RadioError("Unable to write to radio")

def _read(radio, length):

    try:

        data = radio.pipe.read(length)

        LOG.error("Error reading from radio: %s" % e)

        raise errors.RadioError("Unable to read from radio")

        rf.can_odd_split = True

        rf.memory_bounds = (0, 199)

        return rf

    def sync_in(self):

        self._mmap = _download(self)

        self.process_mmap()

    def get_memory(self, number):

        bitpos = (1 << (number % 8))

        _mem = self._memobj.memory[number]

        _skp = self._memobj.skip_flags[bytepos]

    def set_memory(self, mem):

        bitpos = (1 << (mem.number % 8))

        _mem = self._memobj.memory[mem.number]

        _skp = self._memobj.skip_flags[bytepos]

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import struct

from time import sleep

import logging

def encode_base100(v):

def decode_base100(u16):

def drain(pipe):

    """Chew up any data waiting on @pipe"""

        buf = pipe.read(4096)

        if not buf:

            return

def enter_setup(pipe):

    """Put AP510 in configuration mode."""

        if x % 2:

            pipe.write("@SETUP")

        else:

        radio.pipe.write("@DISP")

    buf = ""

        buf += radio.pipe.read(1024)

        if buf.endswith("\r\n"):

            status.cur = status.max

    status.msg = "Uploading"

    status.cur = 1

    for k, v in radio._mmap._memobj.items():

        if k == '00':

            continue

class AP510Memory20141215(AP510Memory):

    """Compatible with firmware version 20141215"""

    def get_multiple(self):

        return dict(zip(

            data = download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        # _mmap isn't a Chirp MemoryMap, but since AP510Memory implements

            upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def load_mmap(self, filename):

        """Load the radio's memory map from @filename"""

        data = mapfile.read()

        if data.startswith('\r\n00=%s 20141215' % self._model):

            self._mmap = AP510Memory20141215(data)

        try:

            system.append(RadioSetting("tx_volume", "Transmit volume",

                          RadioSettingValueList(

            system.append(RadioSetting("rx_volume", "Receive volume",

                          RadioSettingValueList(

            system.append(RadioSetting("squelch", "Squelch",

                          RadioSettingValueList(

                              str(self._mmap.multiple['squelch']))))

            system.append(RadioSetting("tx_serial_ui_out", "Tx serial UI out",

                          RadioSettingValueBoolean(

        try:

            data = _do_ident(radio, magic)

            return data

            error = e

            time.sleep(2)

    if error:

    # UI progress

    status = chirp_common.Status()

    status.cur = 0

    status.msg = "Cloning from radio..."

    radio.status_fn(status)

        data += d

        # UI Update

        status.msg = "Cloning from radio..."

        radio.status_fn(status)

    # UI progress

    status = chirp_common.Status()

    status.cur = 0

    status.msg = "Cloning to radio..."

    radio.status_fn(status)

                raise errors.RadioError(msg)

            # UI Update

            status.msg = "Cloning to radio..."

            radio.status_fn(status)

            _upload(self)

        except errors.RadioError:

            raise

            # If anything unexpected happens, make sure we raise

            # a RadioError and log the problem

            LOG.exception('Unexpected error during upload')

            raise errors.RadioError('Unexpected error communicating '

                                    'with the radio')

    def get_features(self):

        """Get the radio's features"""

        rf.valid_bands = self.VALID_BANDS

        return rf

    def _is_txinh(self, _mem):

        raw_tx = ""

        for i in range(0, 4):

                    elif element.value.get_mutable():

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

                    value = int(val.get_value() * 10)

                LOG.debug("Setting fm_presets = %s" % (value))

                self._memobj.fm_presets = value

                LOG.debug(element.get_name())

                raise

import os

import logging

from chirp import util, chirp_common, bitwise, errors, directory

from chirp.settings import RadioSetting, RadioSettingGroup, \

                RadioSettingValueBoolean, RadioSettingValueList, \

    for _i in range(0, 10):

        try:

            return _uv3r_prep(radio)

            time.sleep(1)

    raise e

        return do_download(radio, 0x0000, 0x0E40, 0x0010)

    except errors.RadioError:

        raise

        raise errors.RadioError("Failed to communicate with radio: %s" % e)

        return do_upload(radio, 0x0000, 0x0E40, 0x0010)

    except errors.RadioError:

        raise

        raise errors.RadioError("Failed to communicate with radio: %s" % e)

                              CH_FLAG_LIST, CH_FLAG_LIST[_settings.ch_flag]))

        basic.append(rs)

        if _limit < 115 or _limit > 239:

            _limit = 144

        rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (115-239 MHz)",

        rs.set_apply_callback(apply_limit, self._memobj.limits)

        basic.append(rs)

        if _limit < 115 or _limit > 239:

            _limit = 146

        rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (115-239 MHz)",

        rs.set_apply_callback(apply_limit, self._memobj.limits)

        basic.append(rs)

        if _limit < 200 or _limit > 529:

            _limit = 420

        rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (200-529 MHz)",

        rs.set_apply_callback(apply_limit, self._memobj.limits)

        basic.append(rs)

        if _limit < 200 or _limit > 529:

            _limit = 450

        rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (200-529 MHz)",

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

                LOG.debug("Setting fm_presets[%1i] = %s" % (index, value))

                setting = self._memobj.fm_presets

                setting[index] = value

                LOG.debug(element.get_name())

                raise

    except errors.RadioError:

        raise

        raise errors.RadioError("Error sending Magic to radio:\n%s" % e)

    _do_ident(radio, status)

    # reset the progress bar in the UI

    status.msg = "Cloning from radio..."

    status.cur = 0

    radio.status_fn(status)

        data += d

        # UI Update

        status.msg = "Cloning from radio..."

        radio.status_fn(status)

    data = radio.get_mmap()

    # Reset the UI progress

    status.cur = 0

    status.msg = "Cloning to radio..."

    radio.status_fn(status)

            raise errors.RadioError("Bad ACK writing block 0x%04x:" % addr)

        # UI Update

        status.msg = "Cloning to radio..."

        radio.status_fn(status)

        """Get the radio's features"""

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_bank = False

        rf.has_tuning_step = False

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error: %s" % e)

    def _decode_tone(self, val, inv):

        rs = RadioSetting("vhfl", "VHF Low Limit",

                          RadioSettingValueInteger(130, 174, int(

        rs.set_apply_callback(apply_limit, _settings)

        adv.append(rs)

        rs = RadioSetting("vhfh", "VHF High Limit",

                          RadioSettingValueInteger(130, 174, int(

        rs.set_apply_callback(apply_limit, _settings)

        adv.append(rs)

        rs = RadioSetting("uhfl", "UHF Low Limit",

                          RadioSettingValueInteger(400, 520, int(

        rs.set_apply_callback(apply_limit, _settings)

        adv.append(rs)

        rs = RadioSetting("uhfh", "UHF High Limit",

                          RadioSettingValueInteger(400, 520, int(

        rs.set_apply_callback(apply_limit, _settings)

        adv.append(rs)

                    setattr(_settings, name, value)

                LOG.debug("Setting %s: %s" % (name, value))

                LOG.debug(element.get_name())

                raise

    # 2 char per byte hex string

    # on CR LF terminated lines of 96 char

    # plus an empty line at the end

    # block are read in same order as original sw eventhough they are not

    # in physical order

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            self._clone_out()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def process_mmap(self):

        _mem = self._memobj.memory[mem.number - 1]

        if mem.empty:

            _mem.namelen = 0

            return

                value = int(val.get_value() * 10 - 870)

                LOG.debug("Setting fm_preset = %s" % (value))

                self._memobj.fm_preset = value

                LOG.debug(element.get_name())

                raise

        rmem = self._memobj.memory[memory.number - 1]

        if memory.empty:

            return

        rmem.rxfreq = memory.freq / 10

            # hits some models more than others.

            #

            # To cope with that we introduce a delay on the writes.

            # after short reads, only for linux, ...)

            # Finally, a static delay was chosen as simplest of all solutions

            # (Michael Wagner, OE4AMW)

    except errors.RadioError:

        raise

        raise errors.RadioError("Error sending Magic to radio:\n%s" % e)

                     util.hexprint(discard))

    # reset the progress bar in the UI

    status.msg = "Cloning from radio..."

    status.cur = 0

    radio.status_fn(status)

        data += d

        # UI Update

        status.msg = "Cloning from radio..."

        radio.status_fn(status)

    data = radio.get_mmap()

    # Reset the UI progress

    status.cur = 0

    status.msg = "Cloning to radio..."

    radio.status_fn(status)

            raise errors.RadioError("Bad ACK writing block 0x%04x:" % addr)

         # UI Update

        status.msg = "Cloning to radio..."

        radio.status_fn(status)

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error: %s" % e)

    def get_raw_memory(self, number):

        if _mem.get_raw()[0] == "\xFF":

            LOG.debug("This mem was empty before")

            mem_was_empty = True

        # if empty memmory

        if mem.empty:

            # the channel itself

        else:

            toa = RadioSetting("settings.apo", "Time out alert timer",

                               RadioSettingValueList(

                                   LIST_OFF1TO10[_mem.settings.apo]))

            basic.append(toa)

            basic.append(ponmsg)

        if self.COLOR_LCD:

                                  "Main LCD foreground color",

                                      RadioSettingValueList(

                                          LIST_COLOR8,

            else:

                tdrab = RadioSetting("settings.tdrab", "TDR return time",

                                     RadioSettingValueList(

                                         LIST_OFF1TO50[_mem.settings.tdrab]))

                basic.append(tdrab)

                for i in range(7, -1, -1):

                    obj.freq[i] = value % 10

                    value /= 10

            _presets = self._memobj.fm_radio_preset

            i = 1

            for preset in _presets:

                                    "Station name " + str(i),

                                        RadioSettingValueString(0, 6, _filter(

                                            preset.broadcast_station_name)))

                                        preset.broadcast_station_name)

                val = RadioSettingValueFloat(0, 108,

                                             convert_bytes_to_freq(

                                                 preset.freq))

                fmfreq.set_apply_callback(apply_fm_freq, preset)

                fm_presets.append(line)

                fm_presets.append(fmfreq)

                i = i + 1

         # DTMF-Setting

                                               "DTMF Decoding Settings")

        top.append(dtmf_enc_settings)

        top.append(dtmf_dec_settings)

                                 "TX-Disable",

                                 RadioSettingValueBoolean(

                                     _mem.dtmf_settings.txdisable))

        dtmf_enc_settings.append(txdisable)

                                 "RX-Disable",

                                 RadioSettingValueBoolean(

                                     _mem.dtmf_settings.rxdisable))

        codes = self._memobj.dtmf_codes

        i = 1

        for dtmfcode in codes:

                                          memory2string(dtmfcode.code),

                                          False, CHARSET_DTMF_DIGITS)

            line = RadioSetting("dtmf_code_" + str(i) + "_code",

            dtmf_enc_settings.append(line)

            i = i + 1

                            "Master and Vice ID",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.mastervice))

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.masterid),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.masterid)

        dtmf_dec_settings.append(line)

                            "Master Inspection",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.minspection))

        dtmf_dec_settings.append(line)

                            "Master Monitor",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.mmonitor))

        dtmf_dec_settings.append(line)

                            "Master Stun",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.mstun))

        dtmf_dec_settings.append(line)

                            "Master Kill",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.mkill))

        dtmf_dec_settings.append(line)

                            "Master Revive",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.mrevive))

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.viceid),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.viceid)

        dtmf_dec_settings.append(line)

                            "Vice Inspection",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.vinspection))

        dtmf_dec_settings.append(line)

                            "Vice Monitor",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.vmonitor))

        dtmf_dec_settings.append(line)

                            "Vice Stun",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.vstun))

        dtmf_dec_settings.append(line)

                            "Vice Kill",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.vkill))

        dtmf_dec_settings.append(line)

                            "Vice Revive",

                            RadioSettingValueBoolean(

                                _mem.dtmf_settings.vrevive))

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.inspection),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.inspection)

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.alarmcode),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.alarmcode)

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.kill),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.kill)

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.monitor),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.monitor)

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.stun),

                                          False, CHARSET_DTMF_DIGITS)

                                _mem.dtmf_settings.stun)

        dtmf_dec_settings.append(line)

                                      memory2string(

                                          _mem.dtmf_settings.revive),

                                          False, CHARSET_DTMF_DIGITS)

        _5tone_standards = self._memobj._5tone_std_settings

        i = 0

        for standard in _5tone_standards:

                                           LIST_5TONE_STANDARDS[i])

            stds_5tone.append(std_5tone)

            period = standard.period

            if period == 255: