m = not (a == b and b == c)

    # attributes
    n = b.c
    b.c = n

    # subscript
    p = b[0]
    b[0] = p

            

Reported by Pylint.

              
    # subscript
    p = b[0]
    b[0] = p
    b[0] += p

    # slice
    a = b[::]


            

Reported by Pylint.

                  # subscript
    p = b[0]
    b[0] = p
    b[0] += p

    # slice
    a = b[::]

    # sequenc unpacking

            

Reported by Pylint.

              
    # sequenc unpacking
    a, b = c
    a, *a = a

    # tuple swapping
    a, b = b, a
    a, b, c = c, b, a


            

Reported by Pylint.

                  a.b()
    a.b(1)
    a.b(c=1)
    a.b(*c)

    # jumps
    if a:
        x
    else:

            

Reported by Pylint.

              
    # jumps
    if a:
        x
    else:
        y
    while a:
        b
    while not a:

            

Reported by Pylint.

                  if a:
        x
    else:
        y
    while a:
        b
    while not a:
        b
    a = a or a

            

Reported by Pylint.

                      del x

    # import
    import a
    from a import b
    #from sys import * # tested at module scope

    # raise
    raise

            

Reported by Pylint.

              
    # import
    import a
    from a import b
    #from sys import * # tested at module scope

    # raise
    raise
    raise 1

            

Reported by Pylint.

                  #from sys import * # tested at module scope

    # raise
    raise
    raise 1

    # return
    return
    return 1

            

Reported by Pylint.

                  bytes_cons = lambda val, enc=None: bytearray(val)
    is_str_type = lambda o: type(o) is str
    is_bytes_type = lambda o: type(o) is bytearray
    is_int_type = lambda o: type(o) is int or type(o) is long
else:
    str_cons = str
    bytes_cons = bytes
    is_str_type = lambda o: type(o) is str
    is_bytes_type = lambda o: type(o) is bytes

            

Reported by Pylint.

              from collections import namedtuple

sys.path.append(sys.path[0] + "/../py")
import makeqstrdata as qstrutil


class FreezeError(Exception):
    def __init__(self, rawcode, msg):
        self.rawcode = rawcode

            

Reported by Pylint.

              
    def freeze(self, parent_name):
        if self.prelude[2] & ~0x0F:
            raise FreezeError("unable to freeze code with relocations")

        self.freeze_children(parent_name)

        # generate native code data
        print()

            

Reported by Pylint.

                          print(er, file=sys.stderr)
            sys.exit(1)
    elif args.merge:
        merged_mpy = merge_mpy(raw_codes, args.output)


if __name__ == "__main__":
    main()

            

Reported by Pylint.

              
import sys
import struct
from collections import namedtuple

sys.path.append(sys.path[0] + "/../py")
import makeqstrdata as qstrutil



            

Reported by Pylint.

              

class FreezeError(Exception):
    def __init__(self, rawcode, msg):
        self.rawcode = rawcode
        self.msg = msg

    def __str__(self):
        return "error while freezing %s: %s" % (self.rawcode.source_file, self.msg)

            

Reported by Pylint.

              

class QStrType:
    def __init__(self, str):
        self.str = str
        self.qstr_esc = qstrutil.qstr_escape(self.str)
        self.qstr_id = "MP_QSTR_" + self.qstr_esc



            

Reported by Pylint.

                  return f, ip - ip_start


def read_prelude_sig(read_byte):
    z = read_byte()
    # xSSSSEAA
    S = (z >> 3) & 0xF
    E = (z >> 2) & 0x1
    F = 0

            

Reported by Pylint.

                  A = z & 0x3
    K = 0
    D = 0
    n = 0
    while z & 0x80:
        z = read_byte()
        # xFSSKAED
        S |= (z & 0x30) << (2 * n)
        E |= (z & 0x02) << n

            

Reported by Pylint.

                  return S, E, F, A, K, D


def read_prelude_size(read_byte):
    I = 0
    C = 0
    n = 0
    while True:
        z = read_byte()

            

Reported by Pylint.

              # Driver for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George

from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine

# for set_orient

            

Reported by Pylint.

              # MIT license; Copyright (c) 2017 Damien P. George

from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine

# for set_orient
PORTRAIT = const(0)

            

Reported by Pylint.

              
from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine

# for set_orient
PORTRAIT = const(0)
LANDSCAPE = const(1)

            

Reported by Pylint.

              from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine

# for set_orient
PORTRAIT = const(0)
LANDSCAPE = const(1)
PORTRAIT_UPSIDEDOWN = const(2)

            

Reported by Pylint.

              from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine

# for set_orient
PORTRAIT = const(0)
LANDSCAPE = const(1)
PORTRAIT_UPSIDEDOWN = const(2)

            

Reported by Pylint.

                      t = 5000
        while t:
            self.i2c.readfrom_into(self.i2c_addr, self.buf1)
            if self.buf1[0] >= n:
                self.i2c.readfrom_into(self.i2c_addr, buf)
                return
            t -= 1
            sleep_ms(1)
        raise OSError(uerrno.ETIMEDOUT)

            

Reported by Pylint.

                      t = 5000
        while t:
            self.i2c.readfrom_into(self.i2c_addr + 1, self.buf1)
            r = self.buf1[0]
            if r >= n:
                return
            t -= 1
            machine.idle()
        raise OSError(uerrno.ETIMEDOUT)

            

Reported by Pylint.

                      self.iflush()
        self._send(b"\x02g0")
        self._waitfor(4, self.buf[5])
        self.w = self.buf[5][1]
        self.h = self.buf[5][2]

    def set_brightness(self, value):
        self._fcmd2("<BBB", 0x16, value)


            

Reported by Pylint.

                      self._send(b"\x02g0")
        self._waitfor(4, self.buf[5])
        self.w = self.buf[5][1]
        self.h = self.buf[5][2]

    def set_brightness(self, value):
        self._fcmd2("<BBB", 0x16, value)

    def set_i2c_addr(self, addr):

            

Reported by Pylint.

                      t = 1000
        while t:
            self.i2c.readfrom_into(self.i2c_addr, self.buf1)
            if self.buf1[0] >= 2:
                self.i2c.readfrom_into(self.i2c_addr, self.buf[3])
                return self.buf[3][1] | self.buf[3][2] << 8
            t -= 1
            sleep_ms(1)
        raise OSError(uerrno.ETIMEDOUT)

            

Reported by Pylint.

              
# this function creates 127 locals
def f():
    x0 = 1
    x1 = 1
    x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1

            

Reported by Pylint.

              # this function creates 127 locals
def f():
    x0 = 1
    x1 = 1
    x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1

            

Reported by Pylint.

              def f():
    x0 = 1
    x1 = 1
    x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1

            

Reported by Pylint.

                  x0 = 1
    x1 = 1
    x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1

            

Reported by Pylint.

                  x1 = 1
    x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1

            

Reported by Pylint.

                  x2 = 1
    x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1
    x10 = 1

            

Reported by Pylint.

                  x3 = 1
    x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1
    x10 = 1
    x11 = 1

            

Reported by Pylint.

                  x4 = 1
    x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1
    x10 = 1
    x11 = 1
    x12 = 1

            

Reported by Pylint.

                  x5 = 1
    x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1
    x10 = 1
    x11 = 1
    x12 = 1
    x13 = 1

            

Reported by Pylint.

                  x6 = 1
    x7 = 1
    x8 = 1
    x9 = 1
    x10 = 1
    x11 = 1
    x12 = 1
    x13 = 1
    x14 = 1

            

Reported by Pylint.

              """

import sys, os, struct, re
from elftools.elf import elffile

sys.path.append(os.path.dirname(__file__) + "/../py")
import makeqstrdata as qstrutil

# MicroPython constants

            

Reported by Pylint.

              from elftools.elf import elffile

sys.path.append(os.path.dirname(__file__) + "/../py")
import makeqstrdata as qstrutil

# MicroPython constants
MPY_VERSION = 5
MP_NATIVE_ARCH_X86 = 1
MP_NATIVE_ARCH_X64 = 2

            

Reported by Pylint.

                      self.link_addr = link_addr

    def isexternal(self):
        return self.sec_name.startswith(".external")

    def istext(self):
        return self.sec_name.startswith(".text")

    def isrodata(self):

            

Reported by Pylint.

                      return self.sec_name.startswith(".external")

    def istext(self):
        return self.sec_name.startswith(".text")

    def isrodata(self):
        return self.sec_name.startswith((".rodata", ".data.rel.ro"))

    def isbss(self):

            

Reported by Pylint.

                      return self.sec_name.startswith(".text")

    def isrodata(self):
        return self.sec_name.startswith((".rodata", ".data.rel.ro"))

    def isbss(self):
        return self.sec_name.startswith(".bss")



            

Reported by Pylint.

                      return self.sec_name.startswith((".rodata", ".data.rel.ro"))

    def isbss(self):
        return self.sec_name.startswith(".bss")


class LiteralEntry:
    def __init__(self, value, offset):
        self.value = value

            

Reported by Pylint.

                  # Extract relevant info about symbol that's being relocated
    s = r.sym
    s_bind = s.entry["st_info"]["bind"]
    s_shndx = s.entry["st_shndx"]
    s_type = s.entry["st_info"]["type"]
    r_offset = r["r_offset"] + text_addr
    r_info_type = r["r_info_type"]
    try:
        # only for RELA sections

            

Reported by Pylint.

              
class MPYOutput:
    def open(self, fname):
        self.f = open(fname, "wb")
        self.prev_base = -1
        self.prev_offset = -1

    def close(self):
        self.f.close()

            

Reported by Pylint.

              class MPYOutput:
    def open(self, fname):
        self.f = open(fname, "wb")
        self.prev_base = -1
        self.prev_offset = -1

    def close(self):
        self.f.close()


            

Reported by Pylint.

                  def open(self, fname):
        self.f = open(fname, "wb")
        self.prev_base = -1
        self.prev_offset = -1

    def close(self):
        self.f.close()

    def write_bytes(self, buf):

            

Reported by Pylint.

              

def Setup():
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

            

Reported by Pylint.

              
def Setup():
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob


            

Reported by Pylint.

              def Setup():
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

    IntGlob = 0

            

Reported by Pylint.

                  global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

    IntGlob = 0
    BoolGlob = FALSE

            

Reported by Pylint.

                  global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

    IntGlob = 0
    BoolGlob = FALSE
    Char1Glob = "\0"

            

Reported by Pylint.

                  global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

    IntGlob = 0
    BoolGlob = FALSE
    Char1Glob = "\0"
    Char2Glob = "\0"

            

Reported by Pylint.

              

def Proc0(loops):
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob

            

Reported by Pylint.

              
def Proc0(loops):
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob
    global PtrGlb

            

Reported by Pylint.

              def Proc0(loops):
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob
    global PtrGlb
    global PtrGlbNext

            

Reported by Pylint.

                  global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob
    global PtrGlb
    global PtrGlbNext


            

Reported by Pylint.

              import os
import argparse
import re
import markdown

# given a list of (name,regex) pairs, find the first one that matches the given line
def re_match_first(regexs, line):
    for name, regex in regexs:
        match = re.match(regex, line)

            

Reported by Pylint.

                      self.para(descr)

    def function(self, ctx, name, args, descr):
        proto = "{}.{}{}".format(ctx, self.name, self.args)
        self.heading(3, "`" + proto + "`")
        self.para(descr)

    def method(self, ctx, name, args, descr):
        if name == "\\constructor":

            

Reported by Pylint.

                      self.para(descr)

    def function(self, ctx, name, args, descr):
        proto = "{}.{}{}".format(ctx, self.name, self.args)
        self.heading(3, "`" + proto + "`")
        self.para(descr)

    def method(self, ctx, name, args, descr):
        if name == "\\constructor":

            

Reported by Pylint.

                      pass

    def start(self):
        self.lines = []

    def end(self):
        return "\n".join(self.lines)

    def heading(self, level, text):

            

Reported by Pylint.

                  def single_line(self, text):
        self.lines.append(text)

    def module(self, name, short_descr, descr):
        self.heading(1, "module {}".format(name))
        self.para(descr)

    def function(self, ctx, name, args, descr):
        proto = "{}.{}{}".format(ctx, self.name, self.args)

            

Reported by Pylint.

                      self.heading(1, "module {}".format(name))
        self.para(descr)

    def function(self, ctx, name, args, descr):
        proto = "{}.{}{}".format(ctx, self.name, self.args)
        self.heading(3, "`" + proto + "`")
        self.para(descr)

    def method(self, ctx, name, args, descr):

            

Reported by Pylint.

                      self.heading(1, "module {}".format(name))
        self.para(descr)

    def function(self, ctx, name, args, descr):
        proto = "{}.{}{}".format(ctx, self.name, self.args)
        self.heading(3, "`" + proto + "`")
        self.para(descr)

    def method(self, ctx, name, args, descr):

            

Reported by Pylint.

                      pass

    def start(self):
        self.lines = []

    def end(self):
        return "\n".join(self.lines)

    def _convert(self, text):

            

Reported by Pylint.

                      self.lines.append("   :synopsis: {}".format(short_descr))
        self.para(descr)

    def function(self, ctx, name, args, descr):
        args = self._convert(args)
        self.lines.append(".. function:: " + name + args)
        self.para(descr, indent="   ")

    def method(self, ctx, name, args, descr):

            

Reported by Pylint.

                          self.lines.append(".. method:: " + ctx + "." + name + args)
        self.para(descr, indent="   ")

    def constant(self, ctx, name, descr):
        self.lines.append(".. data:: " + name)
        self.para(descr, indent="   ")


class DocValidateError(Exception):

            

Reported by Pylint.

              

class Node(object):
    def __init__(self, pos, id, links):
        self.pos = pos
        self.id = id
        self.links = links



            

Reported by Pylint.

                      self.count = 3 * size * (size - 1) + 1
        self.nodes_by_id = self.count * [None]
        self.nodes_by_pos = {}
        id = 0
        for y in range(size):
            for x in range(size + y):
                pos = (x, y)
                node = Node(pos, id, [])
                self.nodes_by_pos[pos] = node

            

Reported by Pylint.

                  def link_nodes(self):
        for node in self.nodes_by_id:
            (x, y) = node.pos
            for dir in DIRS:
                nx = x + dir.x
                ny = y + dir.y
                if self.contains_pos((nx, ny)):
                    node.links.append(self.nodes_by_pos[(nx, ny)].id)


            

Reported by Pylint.

                  def get_by_pos(self, pos):
        return self.nodes_by_pos[pos]

    def get_by_id(self, id):
        return self.nodes_by_id[id]


##################################
class Pos(object):

            

Reported by Pylint.

              
##################################
class Pos(object):
    def __init__(self, hex, tiles, done=None):
        self.hex = hex
        self.tiles = tiles
        self.done = Done(hex.count) if done is None else done

    def clone(self):

            

Reported by Pylint.

              

def print_pos(pos, output):
    hex = pos.hex
    done = pos.done
    size = hex.size
    for y in range(size):
        print(" " * (size - y - 1), end="", file=output)
        for x in range(size + y):

            

Reported by Pylint.

                      print(" " * (size - y - 1), end="", file=output)
        for x in range(size + y):
            pos2 = (x, y)
            id = hex.get_by_pos(pos2).id
            if done.already_done(id):
                c = done[id][0] if done[id][0] != EMPTY else "."
            else:
                c = "?"
            print("%s " % c, end="", file=output)

            

Reported by Pylint.

              IMPOSSIBLE = -1


def solved(pos, output, verbose=False):
    hex = pos.hex
    tiles = pos.tiles[:]
    done = pos.done
    exact = True
    all_done = True

            

Reported by Pylint.

              

def solved(pos, output, verbose=False):
    hex = pos.hex
    tiles = pos.tiles[:]
    done = pos.done
    exact = True
    all_done = True
    for i in range(hex.count):

            

Reported by Pylint.

              

def check_valid(pos):
    hex = pos.hex
    tiles = pos.tiles
    # fill missing entries in tiles
    tot = 0
    for i in range(8):
        if tiles[i] > 0:

            

Reported by Pylint.

                                    try:
                       print(2)
                       break
                       print(3)
                      except:
                       pass
                     except:
                      pass
                    except:

            

Reported by Pylint.

                                     print(2)
                       break
                       print(3)
                      except:
                       pass
                     except:
                      pass
                    except:
                     pass

            

Reported by Pylint.

                                     print(3)
                      except:
                       pass
                     except:
                      pass
                    except:
                     pass
                   except:
                    pass

            

Reported by Pylint.

                                     pass
                     except:
                      pass
                    except:
                     pass
                   except:
                    pass
                  except:
                   pass

            

Reported by Pylint.

                                    pass
                    except:
                     pass
                   except:
                    pass
                  except:
                   pass
                 except:
                  pass

            

Reported by Pylint.

                                   pass
                   except:
                    pass
                  except:
                   pass
                 except:
                  pass
                except:
                 pass

            

Reported by Pylint.

                                  pass
                  except:
                   pass
                 except:
                  pass
                except:
                 pass
               except:
                pass

            

Reported by Pylint.

                                 pass
                 except:
                  pass
                except:
                 pass
               except:
                pass
              except:
               pass

            

Reported by Pylint.

                                pass
                except:
                 pass
               except:
                pass
              except:
               pass
             except:
              pass

            

Reported by Pylint.

                               pass
               except:
                pass
              except:
               pass
             except:
              pass
            except:
             pass

            

Reported by Pylint.

              # flash LED #1 using inline assembler
# this version is overly verbose and uses word stores
@micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)

            

Reported by Pylint.

              # this version is overly verbose and uses word stores
@micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)

            

Reported by Pylint.

              # this version is overly verbose and uses word stores
@micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)

            

Reported by Pylint.

              # this version is overly verbose and uses word stores
@micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)

            

Reported by Pylint.

              # this version is overly verbose and uses word stores
@micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)

            

Reported by Pylint.

              @micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)


            

Reported by Pylint.

              @micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)


            

Reported by Pylint.

              @micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)


            

Reported by Pylint.

              @micropython.asm_thumb
def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)


            

Reported by Pylint.

              def flash_led(r0):
    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
    movw(r2, 1 << 13)
    movt(r2, 0)
    movw(r3, 0)
    movt(r3, 1 << 13)

    b(loop_entry)

            

Reported by Pylint.