Sign upLogin

Maroc-OS/decompiler

View on GitHub
Star
src/filters/controlflow.py

Summary

Maintainability
F
6 days
Test Coverage

File controlflow.py has 545 lines of code (exceeds 250 allowed). Consider refactoring.
Open

""" Control flow reconstruction.

Transforms the control flow into the most readable form possible.
"""
Severity: Major
Found in src/filters/controlflow.py - About 1 day to fix

    Cyclomatic complexity is too high in method connect_next. (24)
    Open

      def connect_next(self, container, blocks, prioritizer=None, exclude=[]):
    stmt = container[-1]
    if type(stmt) == goto_t and stmt.expr.value in self.function.blocks:
      dest = self.function.blocks[stmt.expr.value]
      if dest in blocks or (len(list(dest.jump_from)) == 1 and not dest.node.is_return_node and dest not in exclude):
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function visit has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
    Open

      def visit(function, block, loops, visited, context):
    if block in context:
      added = False
      for loop in loops:
        if loop[0] is block:
    Severity: Minor
    Found in src/filters/controlflow.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function connect_next has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
    Open

      def connect_next(self, container, blocks, prioritizer=None, exclude=[]):
    stmt = container[-1]
    if type(stmt) == goto_t and stmt.expr.value in self.function.blocks:
      dest = self.function.blocks[stmt.expr.value]
      if dest in blocks or (len(list(dest.jump_from)) == 1 and not dest.node.is_return_node and dest not in exclude):
    Severity: Minor
    Found in src/filters/controlflow.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method run. (16)
    Open

      def run(self):
    self.cf.reconstruct_forward(self.conditional.left, self.prioritizer)
    self.cf.reconstruct_forward(self.conditional.right, self.prioritizer)

    if len(self.conditional.left) == 0 and len(self.conditional.right) == 0:
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method visit. (15)
    Open

      @staticmethod
  def visit(function, block, loops, visited, context):
    if block in context:
      added = False
      for loop in loops:
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method reconstruct_forward. (13)
    Open

      def reconstruct_forward(self, blocks, prioritizer=None, exclude=[]):
    if len(blocks) == 0:
      return

    # check if any loops are present, as they must be
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method visit. (10)
    Open

      @staticmethod
  def visit(function, block, conds, visited, context, priors):
    if block in visited:
      diff = conditional_t.diff(priors, context + [block])
      if diff:
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in class assembler_t. (8)
    Open

    class assembler_t(controlflow_common_t):

  def __init__(self, function):
    self.function = function
    return
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method cleanup_loop. (7)
    Open

      def cleanup_loop(self, stmt, loop_block, exit_block):
    if not stmt.container:
      return
    self.expand_branches(self.loop.blocks)
    if type(stmt) == goto_t and stmt.expr.value == exit_block.ea:
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in class conditional_reconstructor_t. (7)
    Open

    class conditional_reconstructor_t(controlflow_common_t):

  def __init__(self, cf, conditional, prioritizer=None):
    self.cf = cf
    self.function = cf.function
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function reconstruct_forward has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
    Open

      def reconstruct_forward(self, blocks, prioritizer=None, exclude=[]):
    if len(blocks) == 0:
      return

    # check if any loops are present, as they must be
    Severity: Minor
    Found in src/filters/controlflow.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method remove_goto. (6)
    Open

      def remove_goto(self, ctn, block):
    """ remove goto going to block at the end of the given container """
    stmt = ctn[-1]
    if type(stmt) == goto_t and stmt.expr.value == block.ea:
      stmt.remove()
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method prioritize_non_conditional_block. (6)
    Open

      def prioritize_non_conditional_block(self, left, right):
    """ Choose which block between left and right should be
        reconstructed first. This prioritizer returns the first
        block that never reaches the loop's conditional block,
        or if both reaches it, the longest path first. """
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method reaches_to. (6)
    Open

      def reaches_to(self, block, end_block, visited):
    if block in visited:
      return False
    visited.append(block)
    to = block.jump_to_ea
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method find_condition. (6)
    Open

      def find_condition(self):
    exit_block = list(set(self.start.jump_to).difference(self.blocks))
    if len(exit_block) == 1 and exit_block[0] in self.exits:
      self.condition_block = self.start
      self.exit_block = exit_block[0]
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method combine_conditions. (6)
    Open

      @classmethod
  def combine_conditions(cls, block):
    """ combine two ifs into a boolean or (||) or a boolean and (&&). """

    if not cls.is_branch_block(block):
    Severity: Minor
    Found in src/filters/controlflow.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function visit has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
    Open

      def visit(function, block, conds, visited, context, priors):
    if block in visited:
      diff = conditional_t.diff(priors, context + [block])
      if diff:
        for cond in conds:
    Severity: Minor
    Found in src/filters/controlflow.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function run has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

      def run(self):
    self.cf.reconstruct_forward(self.conditional.left, self.prioritizer)
    self.cf.reconstruct_forward(self.conditional.right, self.prioritizer)

    if len(self.conditional.left) == 0 and len(self.conditional.right) == 0:
    Severity: Minor
    Found in src/filters/controlflow.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Avoid deeply nested control flow statements.
    Open

                if _block not in loop:
              loop.append(_block)
          added = True
    Severity: Major
    Found in src/filters/controlflow.py - About 45 mins to fix

      Function find_condition has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

        def find_condition(self):
    exit_block = list(set(self.start.jump_to).difference(self.blocks))
    if len(exit_block) == 1 and exit_block[0] in self.exits:
      self.condition_block = self.start
      self.exit_block = exit_block[0]
      Severity: Minor
      Found in src/filters/controlflow.py - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function reaches_to has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

        def reaches_to(self, block, end_block, visited):
    if block in visited:
      return False
    visited.append(block)
    to = block.jump_to_ea
      Severity: Minor
      Found in src/filters/controlflow.py - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function visit has 5 arguments (exceeds 4 allowed). Consider refactoring.
      Open

        def visit(function, block, conds, visited, context, priors):
      Severity: Minor
      Found in src/filters/controlflow.py - About 35 mins to fix

        Function assemble_connected has 5 arguments (exceeds 4 allowed). Consider refactoring.
        Open

          def assemble_connected(self, container, blocks, block, prioritizer=None, exclude=[]):
        Severity: Minor
        Found in src/filters/controlflow.py - About 35 mins to fix

          Function combine_conditions has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
          Open

            def combine_conditions(cls, block):
    """ combine two ifs into a boolean or (||) or a boolean and (&&). """

    if not cls.is_branch_block(block):
      return False
          Severity: Minor
          Found in src/filters/controlflow.py - About 35 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function cleanup_loop has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
          Open

            def cleanup_loop(self, stmt, loop_block, exit_block):
    if not stmt.container:
      return
    self.expand_branches(self.loop.blocks)
    if type(stmt) == goto_t and stmt.expr.value == exit_block.ea:
          Severity: Minor
          Found in src/filters/controlflow.py - About 25 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function run has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
          Open

            def run(self):
    self.loop.started = True

    if self.loop.condition_block is self.loop.start:
      if len(self.loop.blocks) == 1 and len(self.loop.start.container) > 1:
          Severity: Minor
          Found in src/filters/controlflow.py - About 25 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function remove_goto has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
          Open

            def remove_goto(self, ctn, block):
    """ remove goto going to block at the end of the given container """
    stmt = ctn[-1]
    if type(stmt) == goto_t and stmt.expr.value == block.ea:
      stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py - About 25 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function merge_conditions has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
          Open

            def merge_conditions(cls, function):
    """ perform merge of some conditional statements that can be merged without problem """
    merged = None
    while merged is not False:
      for block in function.blocks.values():
          Severity: Minor
          Found in src/filters/controlflow.py - About 25 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function expand_branches has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
          Open

            def expand_branches(self, blocks=None):
    for stmt in iterators.statement_iterator_t(self.function):
      if type(stmt) != branch_t:
        continue
      if blocks and stmt.container.block not in blocks:
          Severity: Minor
          Found in src/filters/controlflow.py - About 25 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

                if dest_false and (dest_false in blocks or (len(list(dest_false.jump_from)) == 1 and not dest_false.node.is_return_node and dest_true not in exclude)):
        self.assemble_connected(container, blocks, dest_false, prioritizer, exclude)
      else:
        container.add(goto_t(None, stmt.false.copy()))
          Severity: Major
          Found in src/filters/controlflow.py and 1 other location - About 5 hrs to fix
          src/filters/controlflow.py on lines 589..592

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 90.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

                if dest_true and (dest_true in blocks or (len(list(dest_true.jump_from)) == 1 and not dest_true.node.is_return_node and dest_true not in exclude)):
        self.assemble_connected(true_ctn, blocks, dest_true, prioritizer, exclude)
      else:
        true_ctn.add(goto_t(None, stmt.true.copy()))
          Severity: Major
          Found in src/filters/controlflow.py and 1 other location - About 5 hrs to fix
          src/filters/controlflow.py on lines 594..597

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 90.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

                if stmt.true.value in function.blocks:
        next = function.blocks[stmt.true.value]
        loop_t.visit(function, next, loops, visited, context[:])
          Severity: Major
          Found in src/filters/controlflow.py and 2 other locations - About 2 hrs to fix
          src/filters/controlflow.py on lines 97..100
          src/filters/controlflow.py on lines 105..107

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 50.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

              if type(stmt) == goto_t and stmt.is_known():
      if stmt.expr.value in function.blocks:
        next = function.blocks[stmt.expr.value]
        loop_t.visit(function, next, loops, visited, context[:])
          Severity: Major
          Found in src/filters/controlflow.py and 2 other locations - About 2 hrs to fix
          src/filters/controlflow.py on lines 102..104
          src/filters/controlflow.py on lines 105..107

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 50.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

                if stmt.false.value in function.blocks:
        next = function.blocks[stmt.false.value]
        loop_t.visit(function, next, loops, visited, context[:])
          Severity: Major
          Found in src/filters/controlflow.py and 2 other locations - About 2 hrs to fix
          src/filters/controlflow.py on lines 97..100
          src/filters/controlflow.py on lines 102..104

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 50.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

              if next.container[-1].false.value == dest:
      cls.invert_goto_condition(next.container[-1])
          Severity: Major
          Found in src/filters/controlflow.py and 1 other location - About 1 hr to fix
          src/filters/controlflow.py on lines 209..210

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 39.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

              if this.container[-1].false.value == dest:
      cls.invert_goto_condition(this.container[-1])
          Severity: Major
          Found in src/filters/controlflow.py and 1 other location - About 1 hr to fix
          src/filters/controlflow.py on lines 212..213

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 39.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

                if stmt.true.value in self.function.blocks:
        dest_true = self.function.blocks[stmt.true.value]
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 55 mins to fix
          src/filters/controlflow.py on lines 573..574

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 37.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

                if stmt.false.value in self.function.blocks:
        dest_false = self.function.blocks[stmt.false.value]
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 55 mins to fix
          src/filters/controlflow.py on lines 571..572

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 37.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

              branches = (self.function.blocks[stmt.true.value], self.function.blocks[stmt.false.value])
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 50 mins to fix
          src/filters/controlflow.py on lines 319..319

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 36.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

                branches = (self.function.blocks[stmt.true.value], self.function.blocks[stmt.false.value])
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 50 mins to fix
          src/filters/controlflow.py on lines 404..404

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 36.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

              left = [this.container[-1].true.value, this.container[-1].false.value]
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 30 mins to fix
          src/filters/controlflow.py on lines 199..199

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 32.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

              right = [next.container[-1].true.value, next.container[-1].false.value]
          Severity: Minor
          Found in src/filters/controlflow.py and 1 other location - About 30 mins to fix
          src/filters/controlflow.py on lines 198..198

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 32.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Indentation is not a multiple of 4
          Open

            def find_condition(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                        loop.append(_block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.expr.value in function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def find(function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.left, self.right = self.right, self.left
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def find_entries(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Continuation line under-indented for visual indent
          Open

                self.top, self.left, self.right, self.bottom)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Continuation lines indentation.

          Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

          Indentation is not a multiple of 4
          Open

                next = function.blocks[stmt.expr.value]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __repr__(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                leads_to = leads_to.union(block.jump_to)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def diff(priors, context):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return conditional_t(block, left, right, prior[0])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.false.value in function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class conditional_t(object):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

                if diff:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    self.condition_block = block
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def attach_breaks(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if len(to) == 1 and to[0] is not exit and to[0] in self.exits:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    if cond.top is diff.top:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if not added:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.true.value in function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                right = list(reversed(ctx[:ctx.index(block)]))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                to = list(exit.jump_to)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                added = False
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def reaches_to(self, block, to):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __init__(self, blocks):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.condition_block = self.start
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    for _block in context[context.index(block):]:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                for loop in loops:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                visited.append(block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    added = True
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __repr__(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if block not in prior:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class loop_t(object):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

            def visit(function, block, loops, visited, context):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __init__(self, top, left, right, bottom):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                left = list(reversed(prior[1:i]))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    self.exit_block = list(to.intersection(self.exits))[0]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def find_exits(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                diff = conditional_t.diff(priors, context + [block])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                visited.append(block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.exit_block = exit_block[0]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                for block in self.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                i = prior.index(block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def visit(function, block, conds, visited, context, priors):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def is_branch_block(block):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                condition = stmt.expr.copy()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (84 > 79 characters)
          Open

                _if = if_t(stmt.ea, condition, container_t(stmt.container.block, [goto_true]))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            def find(function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                elif stmt.false.value == block.ea:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                _if = if_t(stmt.ea, condition, container_t(stmt.container.block, [goto_true]))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                ctn.add(_if)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.true.value == block.ea:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.remove_goto(_if.then_expr, block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __init__(self, cf, loop):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if ea in self.function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def wrap_loop(self, ea, klass, block, condition):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (96 > 79 characters)
          Open

              #print 'prioritize non conditional block', repr(left.container), 'or', repr(right.container)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Continuation line under-indented for visual indent
          Open

                exclude=[self.loop.condition_block])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Continuation lines indentation.

          Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

          Indentation is not a multiple of 4
          Open

                block.container.add(goto_t(stmt.ea, value_t(dest.ea, self.function.arch.address_size)))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                elif left_reach:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Block comment should start with '# '
          Open

              #print repr(self.loop.blocks)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Indentation is not a multiple of 4
          Open

                return right
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class conditional_reconstructor_t(controlflow_common_t):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

            def __init__(self, cf, conditional, prioritizer=None):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (94 > 79 characters)
          Open

              branches = (self.function.blocks[stmt.true.value], self.function.blocks[stmt.false.value])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                raise RuntimeError('something went wrong :(')
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def run(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                block = self.loop.condition_block
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                container.add(stmt)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                expr = stmt.expr.copy()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                _if = if_t(stmt.ea, b_not_t(stmt.expr.copy()), ctn)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                else:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                for _stmt in stmt.statements:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (84 > 79 characters)
          Open

                  self.assemble_connected(container, blocks, dest_false, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            @property
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if first is else_blocks[0]:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (84 > 79 characters)
          Open

                if cond.top in blocks and cond.top not in [loop.start for loop in self.loops]:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                prioritized = True
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (114 > 79 characters)
          Open

              then_ctn = self.cf.assembler.build_container(container_t(self.conditional.top), then_blocks, self.prioritizer)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            def connect_next(self, container, blocks, prioritizer=None, exclude=[]):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.false.value in self.function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if not first in blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def invert_goto_condition(stmt):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (91 > 79 characters)
          Open

              """ perform merge of some conditional statements that can be merged without problem """
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                    break
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if len(self.loop.blocks) == 1 and len(self.loop.start.container) > 1:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return True
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                left_reach = self.reaches_to(left, self.loop.condition_block, [])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def cleanup_loop(self, stmt, loop_block, exit_block):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (125 > 79 characters)
          Open

              self.conditional.top.container.add(goto_t(stmt.ea, value_t(self.conditional.bottom.ea, self.function.arch.address_size)))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                true_ctn = container_t(container.block, [])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                _if = if_t(stmt.ea, expr, true_ctn, None)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if dest_false and (dest_false in blocks or (len(list(dest_false.jump_from)) == 1 and not dest_false.node.is_return_node and dest_true not in exclude)):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def reconstruct(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                container = self.assembler.build_container(container_t(first), blocks, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                cls.invert_goto_condition(this.container[-1])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                _if = if_t(stmt.ea, condition, container_t(block, [goto]))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                branches = (self.function.blocks[stmt.true.value], self.function.blocks[stmt.false.value])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (80 > 79 characters)
          Open

                _while = self.wrap_loop(None, while_t, self.loop.blocks[0], value_t(1, 1))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Line too long (92 > 79 characters)
          Open

              """ combine two if_t that jump to the same destination into a boolean or expression. """
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                _while = self.wrap_loop(None, while_t, self.loop.blocks[0], value_t(1, 1))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                cls.invert_goto_condition(next.container[-1])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                dest, = list(set(block.jump_to).difference(self.loop.exits))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if blocks and stmt.container.block not in blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def remove_goto(self, ctn, block):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.cleanup_loop(_while, self.loop.blocks[0], self.loop.exit_block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (124 > 79 characters)
          Open

              if not prioritized and else_ctn and type(then_ctn[0]) in (if_t, branch_t) and type(else_ctn[0]) not in (if_t, branch_t):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                self.connect_next(container, blocks, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return left
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                dest_true, dest_false = None, None
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                else:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return b_not_t(branch.expr.copy())
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            c.reconstruct()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                expr = b_not_t(expr)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.remove_goto(else_ctn, self.conditional.bottom)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class assembler_t(controlflow_common_t):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

                if dest_true and (dest_true in blocks or (len(list(dest_true.jump_from)) == 1 and not dest_true.node.is_return_node and dest_true not in exclude)):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                first = blocks[0]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (98 > 79 characters)
          Open

                container = self.assembler.build_container(container_t(first), blocks, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            def reconstruct_backwards(self, blocks, start):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.connect_next(_if.then_expr, [])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.remove_goto(ctn, block)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                block = self.loop.condition_block
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt = block.container[-1]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                conditional_t.visit(function, next, conds, visited, context[:], priors)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                block.container.add(_if)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    expr = b_not_t(expr)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return False
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4 (comment)
          Open

            #print 'loops', repr(c.loops)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return False
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if left_reach and right_reach:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def build_container(self, container, blocks, prioritizer=None, exclude=[]):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if prioritizer and dest_true and dest_false:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class controlflow_t(controlflow_common_t):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

                next = function.blocks[stmt.false.value]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if cls.combine_branch_blocks(block.function, block, next):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.container.insert(stmt.index(), goto_false)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Block comment should start with '# '
          Open

              #print 'prioritize non conditional block', repr(left.container), 'or', repr(right.container)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Block comment should start with '# '
          Open

              #print 'left_reach', repr(left_reach)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Indentation is not a multiple of 4
          Open

            def reconstruct_while_loop(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                ctn = container_t(block, [break_t(stmt.ea)])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if dest in blocks or (len(list(dest.jump_from)) == 1 and not dest.node.is_return_node and dest not in exclude):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (153 > 79 characters)
          Open

                if dest_true and (dest_true in blocks or (len(list(dest_true.jump_from)) == 1 and not dest_true.node.is_return_node and dest_true not in exclude)):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            def __init__(self, function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if cond.top in blocks and cond.top not in [loop.start for loop in self.loops]:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Block comment should start with '# '
          Open

            #print 'loops', repr(c.loops)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Indentation is not a multiple of 4 (comment)
          Open

            #print 'conditionals', repr(c.conditionals)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                next = function.blocks[stmt.true.value]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @classmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return False
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                dest, = list(set(block.jump_to).difference(self.loop.exits))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                then_blocks, else_blocks = self.conditional.left, self.conditional.right
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return None
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (157 > 79 characters)
          Open

                if dest_false and (dest_false in blocks or (len(list(dest_false.jump_from)) == 1 and not dest_false.node.is_return_node and dest_true not in exclude)):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                if loop.start in blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.trim(blocks)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                conditional_t.visit(function, next, conds, visited, context[:], priors)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (81 > 79 characters)
          Open

              conditional_t.visit(function, function.entry_block, conditionals, [], [], {})
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Block comment should start with '# '
          Open

              #print 'right_reach', repr(right_reach)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Indentation is not a multiple of 4
          Open

                condition = stmt.expr
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                condition = value_t(1, 1)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.container.insert(stmt.index(), break_t(stmt.ea))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                then_blocks, else_blocks = self.conditional.right, self.conditional.left
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (114 > 79 characters)
          Open

              else_ctn = self.cf.assembler.build_container(container_t(self.conditional.top), else_blocks, self.prioritizer)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                self.function.blocks.pop(block.ea)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def reconstruct_forward(self, blocks, prioritizer=None, exclude=[]):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if container:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            """ combine until no more combinations can be applied. """
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                cls = b_or_t
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if not cls.is_branch_block(next) or len(next.container) != 1:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def merge_conditions(cls, function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if type(stmt) != branch_t:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                else:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (96 > 79 characters)
          Open

                branches = (self.function.blocks[stmt.true.value], self.function.blocks[stmt.false.value])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

            def run(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def prioritize_non_conditional_block(self, left, right):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                right_reach = self.reaches_to(right, self.loop.condition_block, [])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (87 > 79 characters)
          Open

              _while = self.wrap_loop(stmt.ea, do_while_t, self.loop.blocks[0], condition.copy())
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (93 > 79 characters)
          Open

                block.container.add(goto_t(stmt.ea, value_t(dest.ea, self.function.arch.address_size)))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                stmt = block.container[-1]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                return branch.expr.copy()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                block = blocks.pop(0)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def prioritizer(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @classmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def combine_branch_blocks(cls, function, this, next):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                for block in function.blocks.values():
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          class controlflow_common_t(object):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Expected 2 blank lines, found 1
          Open

          class loop_reconstructor_t(controlflow_common_t):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

            def prioritize_longest_path(self, left, right):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.trim(blocks)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def assemble_connected(self, container, blocks, block, prioritizer=None, exclude=[]):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                dest = self.function.blocks[stmt.expr.value]
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if stmt.true.value in self.function.blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                cls = b_and_t
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if block.ea not in self.function.blocks.keys():
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                goto_false = goto_t(stmt.ea, stmt.false.copy())
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                else:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    return True
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                elif right_reach:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (82 > 79 characters)
          Open

              #print 'prioritize longest', repr(left.container), 'or', repr(right.container)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Line too long (104 > 79 characters)
          Open

              block.container.add(goto_t(None, value_t(self.loop.exit_block.ea, self.function.arch.address_size)))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Line too long (87 > 79 characters)
          Open

            def assemble_connected(self, container, blocks, block, prioritizer=None, exclude=[]):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Line too long (82 > 79 characters)
          Open

                  self.assemble_connected(true_ctn, blocks, dest_true, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                raise RuntimeError('something went wrong :(')
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            c = controlflow_t(function)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def trim(self, blocks):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def expand_branches(self, blocks=None):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.container.insert(stmt.index(), _if)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                simplify_expressions.run(_if.expr, deep=True)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def reconstruct_do_while_loop(self, condition_block):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                simplify_expressions.run(_if.expr, deep=True)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                stmt.container.insert(stmt.index(), continue_t(stmt.ea))
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def __init__(self, function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.assemble_connected(container, blocks, block, prioritizer, exclude)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                    dest_true, dest_false = dest_false, dest_true
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                simplify_expressions.run(_if.expr, deep=True)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if loop.started:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                self.function.blocks[first.ea] = first
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Test for membership should be 'not in'
          Open

                if not first in blocks:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Negative comparison should be done using "not in" and "is not".

          Okay: if x not in y:\n    pass
Okay: assert (X in Y or X is Z)
Okay: if not (X in Y):\n    pass
Okay: zz = x is not y
E713: Z = not X in Y
E713: if not X.B in Y:\n    pass
E714: if not X is Y:\n    pass
E714: Z = not X.B is Y

          Indentation is not a multiple of 4
          Open

            @staticmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def combine_conditions(cls, block):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                goto_true = goto_t(stmt.ea, stmt.true.copy())
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (95 > 79 characters)
          Open

                if len(set(branches).intersection(self.loop.exits)) == 1 and self.loop.start in branches:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Block comment should start with '# '
          Open

              #print 'prioritize longest', repr(left.container), 'or', repr(right.container)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Line too long (82 > 79 characters)
          Open

              # remove the branch going into the loop and leave only a way to exit the loop.
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                stmt.remove()
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def conditional_expr(self, src, dest):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                then_ctn, else_ctn = else_ctn, then_ctn
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Expected 2 blank lines, found 1
          Open

          def run(function):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate top-level function and class definitions with two blank lines.

          Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

          Indentation is not a multiple of 4
          Open

                conditional_t.visit(function, next, conds, visited, context[:], priors)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            @classmethod
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                simplify_expressions.run(_if.expr, deep=True)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def is_do_while_loop(self):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                if len(set(branches).intersection(self.loop.exits)) == 1 and self.loop.start in branches:
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (88 > 79 characters)
          Open

              self.cf.reconstruct_forward(self.loop.blocks, self.prioritize_non_conditional_block,
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                self.reconstruct_do_while_loop(self.loop.start)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

            def reaches_to(self, block, end_block, visited):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Block comment should start with '# '
          Open

              #print repr(self.loop.blocks)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          Indentation is not a multiple of 4
          Open

                return
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Indentation is not a multiple of 4
          Open

                first = self.prioritizer(then_blocks[0], else_blocks[0])
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Line too long (117 > 79 characters)
          Open

                if dest in blocks or (len(list(dest.jump_from)) == 1 and not dest.node.is_return_node and dest not in exclude):
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Limit all lines to a maximum of 79 characters.

          There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

          Indentation is not a multiple of 4
          Open

                container.add(_if)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Use indent_size (PEP8 says 4) spaces per indentation level.

          For really old code that you don't want to mess up, you can continue
to use 8-space tabs.

Okay: a = 1
Okay: if a == 0:\n    a = 1
E111:   a = 1
E114:   # a = 1

Okay: for item in items:\n    pass
E112: for item in items:\npass
E115: for item in items:\n# Hi\n    pass

Okay: a = 1\nb = 2
E113: a = 1\n    b = 2
E116: a = 1\n    # b = 2

          Block comment should start with '# '
          Open

            #print 'conditionals', repr(c.conditionals)
          Severity: Minor
          Found in src/filters/controlflow.py by pep8

          Separate inline comments by at least two spaces.

          An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

          There are no issues that match your filters.

          Category
          Status