angr 9.2.132__py3-none-win_amd64.whl → 9.2.133__py3-none-win_amd64.whl

angr/analyses/reaching_definitions/rd_state.py

@@ -56,21 +56,21 @@ class ReachingDefinitionsState:
     """
 
     __slots__ = (
-        "arch",
+        "_canonical_size",
+        "_element_limit",
+        "_environment",
+        "_sp_adjusted",
         "_subject",
+        "_track_consts",
         "_track_tmps",
+        "all_definitions",
         "analysis",
+        "arch",
         "codeloc",
         "codeloc_uses",
-        "live_definitions",
-        "all_definitions",
-        "_canonical_size",
-        "heap_allocator",
-        "_environment",
-        "_track_consts",
-        "_sp_adjusted",
         "exit_observed",
-        "_element_limit",
+        "heap_allocator",
+        "live_definitions",
     )
 
     def __init__(
@@ -177,7 +177,7 @@ class ReachingDefinitionsState:
             return claripy.BVS("stack_base", 32, explicit_name=True)
         if self.arch.bits == 64:
             return claripy.BVS("stack_base", 64, explicit_name=True)
-        raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
+        raise ValueError(f"Unsupported architecture word size {self.arch.bits}")
 
     def _to_signed(self, n):
         if n >= 2 ** (self.arch.bits - 1):

angr/analyses/reassembler.py

@@ -152,7 +152,7 @@ class Label:
         self.var_size = None
 
         if self.name is None:
-            self.name = "label_%d" % next(Label.g_label_ctr)
+            self.name = f"label_{next(Label.g_label_ctr)}"
 
         self.original_addr = original_addr
         self.base_addr = None
@@ -189,7 +189,7 @@ class Label:
         offset = self.offset
         sign = "+" if offset >= 0 else "-"
         offset = abs(offset)
-        return ".%s%s%d" % (self.name, sign, offset)
+        return f".{self.name}{sign}{offset}"
 
     @property
     def offset(self):
@@ -318,7 +318,7 @@ class SymbolManager:
 
         i = 0
         while True:
-            name = "%s_%d" % (symbol_name, i)
+            name = f"{symbol_name}_{i}"
             if name not in self.symbol_names:
                 self.symbol_names.add(name)
                 return name
@@ -473,9 +473,9 @@ class Operand:
     def assembly(self):
         if self.type == OP_TYPE_IMM and self.label:
             if self.label_offset > 0:
-                return "%s + %d" % (self.label.operand_str, self.label_offset)
+                return f"{self.label.operand_str} + {self.label_offset}"
             if self.label_offset < 0:
-                return "%s - %d" % (self.label.operand_str, abs(self.label_offset))
+                return f"{self.label.operand_str} - {abs(self.label_offset)}"
             return self.label.operand_str
 
         if self.type == OP_TYPE_MEM:
@@ -483,13 +483,13 @@ class Operand:
             if self.disp:
                 if self.disp_label:
                     if self.disp_label_offset > 0:
-                        disp = "%s + %d" % (self.disp_label.operand_str, self.disp_label_offset)
+                        disp = f"{self.disp_label.operand_str} + {self.disp_label_offset}"
                     elif self.disp_label_offset < 0:
-                        disp = "%s - %d" % (self.disp_label.operand_str, abs(self.disp_label_offset))
+                        disp = f"{self.disp_label.operand_str} - {abs(self.disp_label_offset)}"
                     else:
                         disp = self.disp_label.operand_str
                 else:
-                    disp = "%d" % self.disp
+                    disp = f"{self.disp}"
 
             base = ""
             if self.base:
@@ -504,12 +504,7 @@ class Operand:
                     disp = "*" + disp
 
                 if self.index:
-                    s = "%s(%s, %%%s, %d)" % (
-                        disp,
-                        base,
-                        CAPSTONE_REG_MAP[self.project.arch.name][self.index],
-                        self.scale,
-                    )
+                    s = f"{disp}({base}, %{CAPSTONE_REG_MAP[self.project.arch.name][self.index]}, {self.scale})"
                 elif self.base:  # not self.index
                     s = f"{disp}({base})"
                 else:
@@ -524,7 +519,7 @@ class Operand:
             if self.index and self.scale:
                 if s:
                     s.append("+")
-                s.append("(%s * %d)" % (CAPSTONE_REG_MAP[self.project.arch.name][self.index], self.scale))
+                s.append(f"({CAPSTONE_REG_MAP[self.project.arch.name][self.index]} * {self.scale})")
 
             if disp:
                 if disp.startswith("-"):
@@ -807,7 +802,7 @@ class Instruction:
                     if op.type in (OP_TYPE_IMM, OP_TYPE_MEM, OP_TYPE_RAW):
                         all_operands[i] = op_asm
                     else:
-                        raise BinaryError("Unsupported operand type %d." % op.type)
+                        raise BinaryError(f"Unsupported operand type {op.type}.")
 
                     if op.type != OP_TYPE_RAW and self.capstone_operand_types[i] == capstone.CS_OP_IMM:
                         if mnemonic.startswith(("j", "call", "loop")):
@@ -1247,7 +1242,7 @@ class Data:
         self._initialize()
 
     def __repr__(self):
-        return "<DataItem %s@%#08x, %d bytes>" % (self.sort, self.addr, self.size)
+        return f"<DataItem {self.sort}@{self.addr:#08x}, {self.size} bytes>"
 
     @property
     def content(self):
@@ -1399,7 +1394,7 @@ class Data:
                     i += self.project.arch.bytes
 
                     if isinstance(symbolized_label, int):
-                        s += "\t%s %d\n" % (directive, symbolized_label)
+                        s += f"\t{directive} {symbolized_label}\n"
                     else:
                         s += f"\t{directive} {symbolized_label.operand_str}\n"
 
@@ -1442,11 +1437,12 @@ class Data:
 
                 show_integer = False
                 if len(addr_to_labels) == 0 or (
-                    len(addr_to_labels) == 1
-                    and self.addr is not None
-                    and next(iter(addr_to_labels.keys())) == self.addr
-                    or self.addr is None
-                    and next(iter(addr_to_labels.keys())) == 0
+                    (
+                        len(addr_to_labels) == 1
+                        and self.addr is not None
+                        and next(iter(addr_to_labels.keys())) == self.addr
+                    )
+                    or (self.addr is None and next(iter(addr_to_labels.keys())) == 0)
                 ):
                     show_integer = True
 
@@ -1474,7 +1470,7 @@ class Data:
                                     content += [f"{label!s}"]
                             addr += 1
 
-                            content += ["\t.byte %d" % c]
+                            content += [f"\t.byte {c}"]
 
             else:
                 integer = struct.unpack(fmt_str, self.content[0])[0]
@@ -1508,10 +1504,10 @@ class Data:
                                 content += [f"{label!s}"]
                         addr += 1
 
-                        content += ["\t.byte %d" % c]
+                        content += [f"\t.byte {c}"]
             else:
                 for piece in self.content:
-                    content += ["\t.byte %d" % c for c in piece]
+                    content += [f"\t.byte {c}" for c in piece]
 
             s += "\n".join(content)
             s += "\n"
@@ -1534,10 +1530,10 @@ class Data:
                                 content += [f"{label!s}"]
                         addr += 1
 
-                        content += ["\t.byte %d" % c]
+                        content += [f"\t.byte {c}"]
             else:
                 for piece in self.content:
-                    content += ["\t.byte %d" % c for c in piece]
+                    content += [f"\t.byte {c}" for c in piece]
 
             s += "\n".join(content)
             s += "\n"
@@ -1554,7 +1550,7 @@ class Data:
 
     def _initialize(self):
         if self.memory_data is None:
-            if self.size is None or self._initial_content is None and self.sort is None:
+            if self.size is None or (self._initial_content is None and self.sort is None):
                 raise BinaryError("You must at least specify size, initial_content, and sort.")
 
             if self.sort == MemoryDataSort.PointerArray:
@@ -2647,8 +2643,7 @@ class Reassembler(Analysis):
         return bool(
             cfg.project.loader.find_section_containing(ptr) is not None
             or cfg.project.loader.find_segment_containing(ptr) is not None
-            or self._extra_memory_regions
-            and next((a < ptr < b for a, b in self._extra_memory_regions), None)
+            or (self._extra_memory_regions and next((a < ptr < b for a, b in self._extra_memory_regions), None))
         )
 
     def _sequence_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size):  # pylint:disable=unused-argument

angr/analyses/s_liveness.py

@@ -29,6 +29,7 @@ class SLivenessAnalysis(Analysis):
         func_graph=None,
         entry=None,
         func_addr: int | None = None,
+        arg_vvars: list[VirtualVariable] | None = None,
     ):
         self.func = func
         self.func_addr = func_addr if func_addr is not None else func.addr
@@ -38,6 +39,7 @@ class SLivenessAnalysis(Analysis):
             if entry is not None
             else next(iter(bb for bb in self.func_graph if bb.addr == self.func_addr and bb.idx is None))
         )
+        self.arg_vvars = arg_vvars or []
 
         self.model = SLivenessModel()
 
@@ -147,6 +149,12 @@ class SLivenessAnalysis(Analysis):
                     live.discard(def_vvar)
                 live |= vvar_use_collector.vvars
 
+            if block.addr == self.func_addr:
+                # deal with function arguments
+                for arg_vvar in self.arg_vvars:
+                    for live_vvar in live:
+                        graph.add_edge(arg_vvar.varid, live_vvar)
+
         return graph
 
 

angr/analyses/s_reaching_definitions/s_rda_view.py

@@ -171,11 +171,8 @@ class SRDAView:
                     starting_stmt_idx = stmt_idx
                 continue
 
-            if (
-                op_type == ObservationPointType.OP_BEFORE
-                and stmt.ins_addr == addr
-                or op_type == ObservationPointType.OP_AFTER
-                and stmt.ins_addr > addr
+            if (op_type == ObservationPointType.OP_BEFORE and stmt.ins_addr == addr) or (
+                op_type == ObservationPointType.OP_AFTER and stmt.ins_addr > addr
             ):
                 starting_stmt_idx = stmt_idx
                 break

angr/analyses/stack_pointer_tracker.py

@@ -79,7 +79,7 @@ class Register:
     Represent a register.
     """
 
-    __slots__ = ("offset", "bitlen")
+    __slots__ = ("bitlen", "offset")
 
     def __init__(self, offset, bitlen):
         self.offset = offset
@@ -103,8 +103,8 @@ class OffsetVal:
     """
 
     __slots__ = (
-        "_reg",
         "_offset",
+        "_reg",
     )
 
     def __init__(self, reg, offset):
@@ -177,7 +177,7 @@ class FrozenStackPointerTrackerState:
     Abstract state for StackPointerTracker analysis with registers and memory values being in frozensets.
     """
 
-    __slots__ = "regs", "memory", "is_tracking_memory", "resilient"
+    __slots__ = "is_tracking_memory", "memory", "regs", "resilient"
 
     def __init__(
         self,
@@ -218,7 +218,7 @@ class StackPointerTrackerState:
     Abstract state for StackPointerTracker analysis.
     """
 
-    __slots__ = "regs", "memory", "is_tracking_memory", "resilient"
+    __slots__ = "is_tracking_memory", "memory", "regs", "resilient"
 
     def __init__(self, regs, memory, is_tracking_memory, resilient: bool):
         self.regs = regs

angr/analyses/typehoon/simple_solver.py

@@ -123,7 +123,7 @@ class SketchNode(SketchNodeBase):
     Represents a node in a sketch graph.
     """
 
-    __slots__ = ("typevar", "upper_bound", "lower_bound")
+    __slots__ = ("lower_bound", "typevar", "upper_bound")
 
     def __init__(self, typevar: TypeVariable | DerivedTypeVariable):
         self.typevar: TypeVariable | DerivedTypeVariable = typevar
@@ -164,8 +164,8 @@ class Sketch:
 
     __slots__ = (
         "graph",
-        "root",
         "node_mapping",
+        "root",
         "solver",
     )
 
@@ -263,7 +263,7 @@ class FORGOTTEN(enum.Enum):
 
 
 class ConstraintGraphNode:
-    __slots__ = ("typevar", "variance", "tag", "forgotten")
+    __slots__ = ("forgotten", "tag", "typevar", "variance")
 
     def __init__(
         self,
@@ -367,7 +367,7 @@ class SimpleSolver:
 
     def __init__(self, bits: int, constraints, typevars):
         if bits not in (32, 64):
-            raise ValueError("Pointer size %d is not supported. Expect 32 or 64." % bits)
+            raise ValueError(f"Pointer size {bits} is not supported. Expect 32 or 64.")
 
         self.bits = bits
         self._constraints: dict[TypeVariable, set[TypeConstraint]] = constraints
@@ -627,10 +627,8 @@ class SimpleSolver:
             for _, dst0, data0 in graph.out_edges(cls0, data=True):
                 if "label" in data0 and data0["label"] is not None:
                     for _, dst1, data1 in graph.out_edges(cls1, data=True):
-                        if (
-                            data0["label"] == data1["label"]
-                            or isinstance(data0["label"], Load)
-                            and isinstance(data1["label"], Store)
+                        if data0["label"] == data1["label"] or (
+                            isinstance(data0["label"], Load) and isinstance(data1["label"], Store)
                         ):
                             SimpleSolver._unify(
                                 equivalence_classes, equivalence_classes[dst0], equivalence_classes[dst1], graph
@@ -1280,4 +1278,4 @@ class SimpleSolver:
             return Pointer32
         if self.bits == 64:
             return Pointer64
-        raise NotImplementedError("Unsupported bits %d" % self.bits)
+        raise NotImplementedError(f"Unsupported bits {self.bits}")

angr/analyses/typehoon/translator.py

@@ -42,7 +42,7 @@ class TypeTranslator:
     #
 
     def struct_name(self):
-        return "struct_%d" % next(self._struct_ctr)
+        return f"struct_{next(self._struct_ctr)}"
 
     #
     # Type translation
@@ -227,7 +227,7 @@ class TypeTranslator:
             return typeconsts.Pointer32(base)
         if self.arch.bits == 64:
             return typeconsts.Pointer64(base)
-        raise TypeError("Unsupported pointer size %d" % self.arch.bits)
+        raise TypeError(f"Unsupported pointer size {self.arch.bits}")
 
 
 TypeConstHandlers = {

angr/analyses/typehoon/typeconsts.py

@@ -189,7 +189,7 @@ class Array(TypeConstant):
     def __repr__(self, memo=None):
         if self.count is None:
             return f"{self.element!r}[?]"
-        return "%r[%d]" % (self.element, self.count)
+        return f"{self.element!r}[{self.count}]"
 
     def __eq__(self, other):
         return type(other) is type(self) and self.element == other.element and self.count == other.count

angr/analyses/typehoon/typevars.py

@@ -26,9 +26,9 @@ class TypeConstraint:
 
 class Equivalence(TypeConstraint):
     __slots__ = (
+        "_cached_hash",
         "type_a",
         "type_b",
-        "_cached_hash",
     )
 
     def __init__(self, type_a, type_b):
@@ -44,10 +44,8 @@ class Equivalence(TypeConstraint):
 
     def __eq__(self, other):
         return type(other) is Equivalence and (
-            self.type_a == other.type_a
-            and self.type_b == other.type_b
-            or self.type_b == other.type_a
-            and self.type_a == other.type_b
+            (self.type_a == other.type_a and self.type_b == other.type_b)
+            or (self.type_b == other.type_a and self.type_a == other.type_b)
         )
 
     def __hash__(self):
@@ -55,7 +53,7 @@ class Equivalence(TypeConstraint):
 
 
 class Existence(TypeConstraint):
-    __slots__ = ("type_", "_cached_hash")
+    __slots__ = ("_cached_hash", "type_")
 
     def __init__(self, type_):
         self.type_ = type_
@@ -85,9 +83,9 @@ class Existence(TypeConstraint):
 
 class Subtype(TypeConstraint):
     __slots__ = (
-        "super_type",
-        "sub_type",
         "_cached_hash",
+        "sub_type",
+        "super_type",
     )
 
     def __init__(self, sub_type: TypeType, super_type: TypeType):
@@ -141,10 +139,10 @@ class Add(TypeConstraint):
     """
 
     __slots__ = (
+        "_cached_hash",
         "type_0",
         "type_1",
         "type_r",
-        "_cached_hash",
     )
 
     def __init__(self, type_0, type_1, type_r):
@@ -210,10 +208,10 @@ class Sub(TypeConstraint):
     """
 
     __slots__ = (
+        "_cached_hash",
         "type_0",
         "type_1",
         "type_r",
-        "_cached_hash",
     )
 
     def __init__(self, type_0, type_1, type_r):
@@ -277,7 +275,7 @@ _typevariable_counter = count()
 
 
 class TypeVariable:
-    __slots__ = ("idx", "name", "_cached_hash")
+    __slots__ = ("_cached_hash", "idx", "name")
 
     def __init__(self, idx: int | None = None, name: str | None = None):
         if idx is None:
@@ -310,11 +308,11 @@ class TypeVariable:
     def __repr__(self):
         if self.name:
             return f"{self.name}|tv_{self.idx:02d}"
-        return "tv_%02d" % self.idx
+        return f"tv_{self.idx:02d}"
 
 
 class DerivedTypeVariable(TypeVariable):
-    __slots__ = ("type_var", "labels")
+    __slots__ = ("labels", "type_var")
 
     labels: tuple[BaseLabel, ...]
 
@@ -398,8 +396,8 @@ class DerivedTypeVariable(TypeVariable):
 
 class TypeVariables:
     __slots__ = (
-        "_typevars",
         "_last_typevars",
+        "_typevars",
     )
 
     def __init__(self):
@@ -418,7 +416,7 @@ class TypeVariables:
         #    sum(len(v) for v in self._typevars.items()),
         #    len(self._typevars),
         # )
-        return "{TypeVars: %d items}" % len(self._typevars)
+        return f"{{TypeVars: {len(self._typevars)} items}}"
 
     def add_type_variable(self, var: SimVariable, codeloc, typevar: TypeType):  # pylint:disable=unused-argument
         if var not in self._typevars:
@@ -514,7 +512,7 @@ class AddN(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "+%d" % self.n
+        return f"+{self.n}"
 
 
 class SubN(BaseLabel):
@@ -525,7 +523,7 @@ class SubN(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "-%d" % self.n
+        return f"-{self.n}"
 
 
 class ConvertTo(BaseLabel):
@@ -536,13 +534,13 @@ class ConvertTo(BaseLabel):
         super().__init__()
 
     def __repr__(self):
-        return "conv(%d)" % self.to_bits
+        return f"conv({self.to_bits})"
 
 
 class ReinterpretAs(BaseLabel):
     __slots__ = (
-        "to_type",
         "to_bits",
+        "to_type",
     )
 
     def __init__(self, to_type, to_bits):

angr/analyses/unpacker/__init__.py

@@ -3,4 +3,4 @@ from .packing_detector import PackingDetector
 from .obfuscation_detector import ObfuscationDetector
 
 
-__all__ = ("PackingDetector", "ObfuscationDetector")
+__all__ = ("ObfuscationDetector", "PackingDetector")

angr/analyses/variable_recovery/engine_base.py

@@ -35,9 +35,9 @@ class RichR(Generic[RichRT_co]):
 
     __slots__ = (
         "data",
-        "variable",
-        "typevar",
         "type_constraints",
+        "typevar",
+        "variable",
     )
 
     def __init__(
@@ -384,8 +384,7 @@ class SimEngineVRBase(
         if (
             vvar.category == ailment.expression.VirtualVariableCategory.REGISTER
             and vvar.oident in (self.project.arch.ip_offset, self.project.arch.sp_offset, self.project.arch.lr_offset)
-            or not create_variable
-        ):
+        ) or not create_variable:
             # only store the value. don't worry about variables.
             self.vvar_region[vvar_id] = richr.data
             return

angr/analyses/variable_recovery/variable_recovery_base.py

@@ -327,7 +327,7 @@ class VariableRecoveryStateBase:
             base = 0x7F_FFFF_FFFE_0000
             mask = 0xFFFF_FFFF_FFFF_FFFF
         else:
-            raise AngrRuntimeError("Unsupported bits %d" % self.arch.bits)
+            raise AngrRuntimeError(f"Unsupported bits {self.arch.bits}")
         return (offset + base) & mask
 
     @property

angr/analyses/variable_recovery/variable_recovery_fast.py

@@ -74,11 +74,7 @@ class VariableRecoveryFastState(VariableRecoveryStateBase):
         self.ret_val_size = ret_val_size
 
     def __repr__(self):
-        return "<VRAbstractState@%#x: %d register variables, %d stack variables>" % (
-            self.block_addr,
-            len(self.register_region),
-            len(self.stack_region),
-        )
+        return f"<VRAbstractState@{self.block_addr:#x}: {len(self.register_region)} register variables, {len(self.stack_region)} stack variables>"
 
     def __eq__(self, other):
         if type(other) is not VariableRecoveryFastState:
@@ -523,7 +519,7 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
             256: pyvex.const.V256,
         }
         if size not in mapping:
-            raise TypeError("Unsupported size %d." % size)
+            raise TypeError(f"Unsupported size {size}.")
         return mapping.get(size)(value)
 
     def _peephole_optimize(self, block: Block):

angr/analyses/veritesting.py

@@ -339,7 +339,7 @@ class Veritesting(Analysis):
             for merge_point_addr, merge_point_looping_times in merge_points:
                 manager.stash(
                     lambda s, merge_point_addr=merge_point_addr: s.addr == merge_point_addr,
-                    to_stash="_merge_%x_%d" % (merge_point_addr, merge_point_looping_times),
+                    to_stash=f"_merge_{merge_point_addr:x}_{merge_point_looping_times}",
                 )
 
             # Try to merge a set of previously stashed paths, and then unstash them
@@ -370,7 +370,7 @@ class Veritesting(Analysis):
             if merged_anything:
                 break
 
-            stash_name = "_merge_%x_%d" % (merge_point_addr, merge_point_looping_times)
+            stash_name = f"_merge_{merge_point_addr:x}_{merge_point_looping_times}"
             if stash_name not in manager.stashes:
                 continue
 

angr/analyses/vfg.py

@@ -93,11 +93,11 @@ class PendingJob:
 
     __slots__ = (
         "block_id",
-        "state",
         "call_stack",
         "src_block_id",
-        "src_stmt_idx",
         "src_ins_addr",
+        "src_stmt_idx",
+        "state",
     )
 
     def __init__(
@@ -147,7 +147,7 @@ class FunctionAnalysis(AnalysisTask):
         self.jobs = []
 
     def __repr__(self):
-        return "<Function @ %#08x with %d jobs>" % (self.function_address, len(self.jobs))
+        return f"<Function @ {self.function_address:#08x} with {len(self.jobs)} jobs>"
 
     #
     # Properties
@@ -182,7 +182,7 @@ class CallAnalysis(AnalysisTask):
         self._final_jobs = []
 
     def __repr__(self):
-        return "<Call @ %#08x with %d function tasks>" % (self.address, len(self.function_analysis_tasks))
+        return f"<Call @ {self.address:#08x} with {len(self.function_analysis_tasks)} function tasks>"
 
     #
     # Properties
@@ -1668,7 +1668,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
             except SimValueError:
                 l.debug("-  target cannot be concretized. %s [%s]", job.dbg_exit_status[suc], suc.history.jumpkind)
         l.debug("Remaining/pending jobs: %d/%d", len(self._job_info_queue), len(self._pending_returns))
-        l.debug("Remaining jobs: %s", ["%s %d" % (ent.job, id(ent.job)) for ent in self._job_info_queue])
+        l.debug("Remaining jobs: %s", [f"{ent.job} {id(ent.job)}" for ent in self._job_info_queue])
         l.debug("Task stack: %s", self._task_stack)
 
     @staticmethod

angr/angrdb/serializers/__init__.py

@@ -5,6 +5,6 @@ from .kb import KnowledgeBaseSerializer
 
 
 __all__ = (
-    "LoaderSerializer",
     "KnowledgeBaseSerializer",
+    "LoaderSerializer",
 )

angr/annocfg.py

@@ -229,7 +229,7 @@ class AnnotatedCFG:
         whitelist = self.get_whitelisted_statements(irsb_addr)
         for i in range(len(statements)):
             line = "+" if whitelist is None or i in whitelist else "-"
-            line += "[% 3d] " % i
+            line += f"[{i: 3d}] "
             # We cannot get data returned by pp(). WTF?
             print(line, end="")
             statements[i].pp()