angr 9.2.132__py3-none-manylinux2014_x86_64.whl → 9.2.134__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/structured_codegen/c.py

@@ -388,16 +388,16 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
 
     __slots__ = (
         "addr",
-        "name",
-        "functy",
         "arg_list",
-        "statements",
-        "variables_in_use",
-        "variable_manager",
         "demangled_name",
-        "unified_local_vars",
-        "show_demangled_name",
+        "functy",
+        "name",
         "omit_header",
+        "show_demangled_name",
+        "statements",
+        "unified_local_vars",
+        "variable_manager",
+        "variables_in_use",
     )
 
     def __init__(
@@ -492,7 +492,7 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
             if variable.name:
                 name = variable.name
             elif isinstance(variable, SimTemporaryVariable):
-                name = "tmp_%d" % variable.tmp_id
+                name = f"tmp_{variable.tmp_id}"
             else:
                 name = str(variable)
 
@@ -728,8 +728,8 @@ class CWhileLoop(CLoop):
     """
 
     __slots__ = (
-        "condition",
         "body",
+        "condition",
         "tags",
     )
 
@@ -776,8 +776,8 @@ class CDoWhileLoop(CLoop):
     """
 
     __slots__ = (
-        "condition",
         "body",
+        "condition",
         "tags",
     )
 
@@ -826,7 +826,7 @@ class CForLoop(CStatement):
     Represents a for-loop in C.
     """
 
-    __slots__ = ("initializer", "condition", "iterator", "body", "tags")
+    __slots__ = ("body", "condition", "initializer", "iterator", "tags")
 
     def __init__(self, initializer, condition, iterator, body, tags=None, **kwargs):
         super().__init__(**kwargs)
@@ -878,7 +878,7 @@ class CIfElse(CStatement):
     Represents an if-else construct in C.
     """
 
-    __slots__ = ("condition_and_nodes", "else_node", "simplify_else_scope", "cstyle_ifs", "tags")
+    __slots__ = ("condition_and_nodes", "cstyle_ifs", "else_node", "simplify_else_scope", "tags")
 
     def __init__(
         self,
@@ -1085,7 +1085,7 @@ class CSwitchCase(CStatement):
     Represents a switch-case statement in C.
     """
 
-    __slots__ = ("switch", "cases", "default", "tags")
+    __slots__ = ("cases", "default", "switch", "tags")
 
     def __init__(self, switch, cases, default, tags=None, **kwargs):
         super().__init__(**kwargs)
@@ -1144,7 +1144,7 @@ class CIncompleteSwitchCase(CStatement):
     structuring fails (for whatever reason).
     """
 
-    __slots__ = ("head", "cases", "tags")
+    __slots__ = ("cases", "head", "tags")
 
     def __init__(self, head, cases, tags=None, **kwargs):
         super().__init__(**kwargs)
@@ -1221,20 +1221,30 @@ class CAssignment(CStatement):
             "Shl": "<<",
             "Sar": ">>",
         }
+        commutative_ops = {"Add", "Mul", "And", "Xor", "Or"}
 
+        compound_expr_rhs = None
         if (
             self.codegen.use_compound_assignments
             and isinstance(self.lhs, CVariable)
             and isinstance(self.rhs, CBinaryOp)
-            and isinstance(self.rhs.lhs, CVariable)
-            and self.lhs.unified_variable is not None
-            and self.rhs.lhs.unified_variable is not None
-            and self.lhs.unified_variable is self.rhs.lhs.unified_variable
             and self.rhs.op in compound_assignment_ops
+            and self.lhs.unified_variable is not None
         ):
+            if isinstance(self.rhs.lhs, CVariable) and self.lhs.unified_variable is self.rhs.lhs.unified_variable:
+                compound_expr_rhs = self.rhs.rhs
+            elif (
+                self.rhs.op in commutative_ops
+                and isinstance(self.rhs.rhs, CVariable)
+                and self.lhs.unified_variable is self.rhs.rhs.unified_variable
+            ):
+                compound_expr_rhs = self.rhs.lhs
+
+        if compound_expr_rhs is not None:
             # a = a + x  =>  a += x
+            # a = x + a  =>  a += x
             yield f" {compound_assignment_ops[self.rhs.op]}= ", self
-            yield from CExpression._try_c_repr_chunks(self.rhs.rhs)
+            yield from CExpression._try_c_repr_chunks(compound_expr_rhs)
         else:
             yield " = ", self
             yield from CExpression._try_c_repr_chunks(self.rhs)
@@ -1251,15 +1261,15 @@ class CFunctionCall(CStatement, CExpression):
     """
 
     __slots__ = (
-        "callee_target",
-        "callee_func",
         "args",
-        "returning",
-        "ret_expr",
-        "tags",
+        "callee_func",
+        "callee_target",
         "is_expr",
+        "ret_expr",
+        "returning",
         "show_demangled_name",
         "show_disambiguated_name",
+        "tags",
     )
 
     def __init__(
@@ -1397,9 +1407,9 @@ class CReturn(CStatement):
 
 class CGoto(CStatement):
     __slots__ = (
+        "tags",
         "target",
         "target_idx",
-        "tags",
     )
 
     def __init__(self, target, target_idx, tags=None, **kwargs):
@@ -1481,9 +1491,9 @@ class CLabel(CStatement):
     """
 
     __slots__ = (
-        "name",
-        "ins_addr",
         "block_idx",
+        "ins_addr",
+        "name",
         "tags",
     )
 
@@ -1504,9 +1514,9 @@ class CLabel(CStatement):
 
 class CStructField(CExpression):
     __slots__ = (
-        "struct_type",
-        "offset",
         "field",
+        "offset",
+        "struct_type",
         "tags",
     )
 
@@ -1558,10 +1568,10 @@ class CVariable(CExpression):
     """
 
     __slots__ = (
+        "tags",
+        "unified_variable",
         "variable",
         "variable_type",
-        "unified_variable",
-        "tags",
     )
 
     def __init__(self, variable: SimVariable, unified_variable=None, variable_type=None, tags=None, **kwargs):
@@ -1583,7 +1593,7 @@ class CVariable(CExpression):
         if v.name:
             return v.name
         if isinstance(v, SimTemporaryVariable):
-            return "tmp_%d" % v.tmp_id
+            return f"tmp_{v.tmp_id}"
         return str(v)
 
     def c_repr_chunks(self, indent=0, asexpr=False):
@@ -1766,7 +1776,7 @@ class CBinaryOp(CExpression):
     Binary operations.
     """
 
-    __slots__ = ("op", "lhs", "rhs", "tags", "common_type", "_cstyle_null_cmp")
+    __slots__ = ("_cstyle_null_cmp", "common_type", "lhs", "op", "rhs", "tags")
 
     def __init__(self, op, lhs, rhs, tags: dict | None = None, **kwargs):
         super().__init__(**kwargs)
@@ -2038,9 +2048,9 @@ class CBinaryOp(CExpression):
 
 class CTypeCast(CExpression):
     __slots__ = (
-        "src_type",
         "dst_type",
         "expr",
+        "src_type",
         "tags",
     )
 
@@ -2080,9 +2090,9 @@ class CTypeCast(CExpression):
 
 class CConstant(CExpression):
     __slots__ = (
-        "value",
         "reference_values",
         "tags",
+        "value",
     )
 
     def __init__(self, value, type_: SimType, reference_values=None, tags: dict | None = None, **kwargs):
@@ -2133,11 +2143,8 @@ class CConstant(CExpression):
             result = False
             if isinstance(self.value, int):
                 value_size = self._type.size if self._type is not None else None
-                if (
-                    value_size == 32
-                    and 0xF000_0000 <= self.value <= 0xFFFF_FFFF
-                    or value_size == 64
-                    and 0xF000_0000_0000_0000 <= self.value <= 0xFFFF_FFFF_FFFF_FFFF
+                if (value_size == 32 and 0xF000_0000 <= self.value <= 0xFFFF_FFFF) or (
+                    value_size == 64 and 0xF000_0000_0000_0000 <= self.value <= 0xFFFF_FFFF_FFFF_FFFF
                 ):
                     result = True
 
@@ -2304,8 +2311,8 @@ class CRegister(CExpression):
 class CITE(CExpression):
     __slots__ = (
         "cond",
-        "iftrue",
         "iffalse",
+        "iftrue",
         "tags",
     )
 
@@ -2339,7 +2346,7 @@ class CMultiStatementExpression(CExpression):
     (stmt0, stmt1, stmt2, expr)
     """
 
-    __slots__ = ("stmts", "expr", "tags")
+    __slots__ = ("expr", "stmts", "tags")
 
     def __init__(self, stmts: CStatements, expr: CExpression, tags=None, **kwargs):
         super().__init__(**kwargs)

angr/analyses/decompiler/structuring/__init__.py

@@ -20,11 +20,11 @@ def structurer_class_from_name(name: str) -> type | None:
 
 
 __all__ = (
+    "DEFAULT_STRUCTURER",
+    "STRUCTURER_CLASSES",
     "DreamStructurer",
     "PhoenixStructurer",
-    "SAILRStructurer",
     "RecursiveStructurer",
-    "STRUCTURER_CLASSES",
-    "DEFAULT_STRUCTURER",
+    "SAILRStructurer",
     "structurer_class_from_name",
 )

angr/analyses/decompiler/structuring/phoenix.py

@@ -306,7 +306,8 @@ class PhoenixStructurer(StructurerBase):
                     and isinstance(head_block.nodes[0], Block)
                     and head_block.nodes[0].statements
                     and isinstance(first_nonlabel_nonphi_statement(head_block.nodes[0]), ConditionalJump)
-                    or isinstance(head_block, Block)
+                ) or (
+                    isinstance(head_block, Block)
                     and head_block.statements
                     and isinstance(first_nonlabel_nonphi_statement(head_block), ConditionalJump)
                 ):
@@ -1747,10 +1748,8 @@ class PhoenixStructurer(StructurerBase):
                 and right not in graph
                 and full_graph.in_degree[left] == 1
                 and (
-                    full_graph.in_degree[right] == 2
-                    and left_succs == [right]
-                    or full_graph.in_degree[right] == 1
-                    and not left_succs
+                    (full_graph.in_degree[right] == 2 and left_succs == [right])
+                    or (full_graph.in_degree[right] == 1 and not left_succs)
                 )
             ):
                 edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, start_node, left)
@@ -2384,17 +2383,19 @@ class PhoenixStructurer(StructurerBase):
                     and last_stmt.target.value == dst_addr
                     and (dst_idx is ... or last_stmt.target_idx == dst_idx)
                 )
-                or isinstance(last_stmt, ConditionalJump)
-                and (
-                    (
-                        isinstance(last_stmt.true_target, Const)
-                        and last_stmt.true_target.value == dst_addr
-                        and (dst_idx is ... or last_stmt.true_target_idx == dst_idx)
-                    )
-                    or (
-                        isinstance(last_stmt.false_target, Const)
-                        and last_stmt.false_target.value == dst_addr
-                        and (dst_idx is ... or last_stmt.false_target_idx == dst_idx)
+                or (
+                    isinstance(last_stmt, ConditionalJump)
+                    and (
+                        (
+                            isinstance(last_stmt.true_target, Const)
+                            and last_stmt.true_target.value == dst_addr
+                            and (dst_idx is ... or last_stmt.true_target_idx == dst_idx)
+                        )
+                        or (
+                            isinstance(last_stmt.false_target, Const)
+                            and last_stmt.false_target.value == dst_addr
+                            and (dst_idx is ... or last_stmt.false_target_idx == dst_idx)
+                        )
                     )
                 )
                 or (
@@ -2431,10 +2432,8 @@ class PhoenixStructurer(StructurerBase):
 
         def _handle_BreakNode(break_node: BreakNode, parent=None, **kwargs):  # pylint:disable=unused-argument
             walker.block_id += 1
-            if (
-                break_node.target == dst_addr
-                or isinstance(break_node.target, Const)
-                and break_node.target.value == dst_addr
+            if break_node.target == dst_addr or (
+                isinstance(break_node.target, Const) and break_node.target.value == dst_addr
             ):
                 # FIXME: idx is ignored
                 walker.parent_and_block.append((walker.block_id, parent, break_node))

angr/analyses/decompiler/structuring/structurer_base.py

@@ -150,7 +150,7 @@ class StructurerBase(Analysis):
                 if isinstance(stmt, ailment.Stmt.Jump):
                     targets = extract_jump_targets(stmt)
                     for t in targets:
-                        if t in cases or default is not None and t == default.addr:
+                        if t in cases or (default is not None and t == default.addr):
                             # the node after switch cannot be one of the nodes in the switch-case construct
                             continue
                         goto_addrs[t] += 1
@@ -863,7 +863,7 @@ class StructurerBase(Analysis):
         addr = node_0.addr if node_0.addr is not None else node_1.addr
 
         # fix the last block of node_0 and remove useless goto statements
-        if isinstance(node_0, SequenceNode) and node_0.nodes or isinstance(node_0, MultiNode) and node_0.nodes:
+        if (isinstance(node_0, SequenceNode) and node_0.nodes) or (isinstance(node_0, MultiNode) and node_0.nodes):
             last_node = node_0.nodes[-1]
         elif isinstance(node_0, ailment.Block):
             last_node = node_0

angr/analyses/decompiler/structuring/structurer_nodes.py

@@ -17,9 +17,9 @@ class EmptyBlockNotice(Exception):
 
 class MultiNode:
     __slots__ = (
-        "nodes",
         "addr",
         "idx",
+        "nodes",
     )
 
     def __init__(self, nodes, addr=None, idx=None):
@@ -48,7 +48,7 @@ class MultiNode:
                 addrs.append(node.addr)
             s = f": {min(addrs):#x}-{max(addrs):#x}"
 
-        return "<MultiNode %#x of %d nodes%s>" % (self.addr, len(self.nodes), s)
+        return f"<MultiNode {self.addr:#x} of {len(self.nodes)} nodes{s}>"
 
     def __hash__(self):
         # changing self.nodes does not change the hash, which enables in-place editing
@@ -110,8 +110,8 @@ class SequenceNode(BaseNode):
 
     def __repr__(self):
         if self.addr is None:
-            return "<SequenceNode, %d nodes>" % len(self.nodes)
-        return "<SequenceNode %#x, %d nodes>" % (self.addr, len(self.nodes))
+            return f"<SequenceNode, {len(self.nodes)} nodes>"
+        return f"<SequenceNode {self.addr:#x}, {len(self.nodes)} nodes>"
 
     def add_node(self, node):
         self.nodes.append(node)
@@ -192,11 +192,11 @@ class CodeNode(BaseNode):
 class ConditionNode(BaseNode):
     __slots__ = (
         "addr",
+        "condition",
+        "false_node",
         "node",
         "reaching_condition",
-        "condition",
         "true_node",
-        "false_node",
     )
 
     def __init__(self, addr, reaching_condition, condition, true_node, false_node=None):
@@ -238,13 +238,13 @@ class CascadingConditionNode(BaseNode):
 
 class LoopNode(BaseNode):
     __slots__ = (
-        "sort",
+        "_addr",
+        "_continue_addr",
         "condition",
-        "sequence_node",
         "initializer",
         "iterator",
-        "_addr",
-        "_continue_addr",
+        "sequence_node",
+        "sort",
     )
 
     def __init__(
@@ -351,10 +351,10 @@ class ConditionalBreakNode(BreakNode):
 
 class SwitchCaseNode(BaseNode):
     __slots__ = (
-        "switch_expr",
+        "addr",
         "cases",
         "default_node",
-        "addr",
+        "switch_expr",
     )
 
     def __init__(self, switch_expr, cases: OrderedDict[int | tuple[int, ...], SequenceNode], default_node, addr=None):
@@ -370,7 +370,7 @@ class IncompleteSwitchCaseNode(BaseNode):
     into a SwitchCaseNode by the end of structuring. Only used in Phoenix structurer.
     """
 
-    __slots__ = ("addr", "head", "cases")
+    __slots__ = ("addr", "cases", "head")
 
     def __init__(self, addr, head, cases: list):
         self.addr = addr
@@ -388,7 +388,7 @@ class IncompleteSwitchCaseHeadStatement(ailment.statement.Statement):
     Describes a switch-case head. This is only created by LoweredSwitchSimplifier.
     """
 
-    __slots__ = ("addr", "switch_variable", "case_addrs", "_case_addrs_str")
+    __slots__ = ("_case_addrs_str", "addr", "case_addrs", "switch_variable")
 
     def __init__(self, idx, switch_variable, case_addrs, **kwargs):
         super().__init__(idx, **kwargs)

angr/analyses/deobfuscator/__init__.py

@@ -10,9 +10,9 @@ from .api_obf_peephole_optimizer import APIObfType1PeepholeOptimizer
 
 
 __all__ = (
-    "StringObfuscationFinder",
+    "APIObfType1PeepholeOptimizer",
+    "APIObfuscationFinder",
     "StringObfType1PeepholeOptimizer",
     "StringObfType3Rewriter",
-    "APIObfuscationFinder",
-    "APIObfType1PeepholeOptimizer",
+    "StringObfuscationFinder",
 )

angr/analyses/deobfuscator/string_obf_opt_passes.py

@@ -44,7 +44,7 @@ class StringObfType3Rewriter(OptimizationPass):
 
     @staticmethod
     def is_call_or_call_assignment(stmt) -> bool:
-        return isinstance(stmt, Call) or isinstance(stmt, Assignment) and isinstance(stmt.src, Call)
+        return isinstance(stmt, Call) or (isinstance(stmt, Assignment) and isinstance(stmt.src, Call))
 
     def _analyze(self, cache=None):
 

angr/analyses/disassembly.py

@@ -119,9 +119,9 @@ class Label(DisassemblyPiece):
 class IROp(DisassemblyPiece):
     __slots__ = (
         "addr",
-        "seq",
-        "obj",
         "irsb",
+        "obj",
+        "seq",
     )
 
     addr: int
@@ -444,7 +444,7 @@ class SootExpressionTarget(SootExpression):
         self.target_stmt_idx = target_stmt_idx
 
     def _render(self, formatting=None):
-        return ["Goto %d" % self.target_stmt_idx]
+        return [f"Goto {self.target_stmt_idx}"]
 
 
 class SootExpressionStaticFieldRef(SootExpression):
@@ -898,7 +898,7 @@ class Value(OperandPiece):
                     return [f"{self.val:#x}"]
                 if style[0] == "dec":
                     if self.render_with_sign:
-                        return ["%+d" % self.val]
+                        return [f"{self.val:+d}"]
                     return [str(self.val)]
                 if style[0] == "label":
                     labeloffset = style[1]

angr/analyses/forward_analysis/__init__.py

@@ -4,8 +4,8 @@ from .forward_analysis import ForwardAnalysis
 from .visitors import CallGraphVisitor, FunctionGraphVisitor, LoopVisitor, SingleNodeGraphVisitor
 
 __all__ = (
-    "ForwardAnalysis",
     "CallGraphVisitor",
+    "ForwardAnalysis",
     "FunctionGraphVisitor",
     "LoopVisitor",
     "SingleNodeGraphVisitor",

angr/analyses/forward_analysis/visitors/graph.py

@@ -16,14 +16,14 @@ class GraphVisitor(Generic[NodeType]):
     """
 
     __slots__ = (
-        "_sorted_nodes",
-        "_worklist",
-        "_nodes_set",
-        "_node_to_index",
-        "_reached_fixedpoint",
-        "_back_edges_by_src",
         "_back_edges_by_dst",
+        "_back_edges_by_src",
+        "_node_to_index",
+        "_nodes_set",
         "_pending_nodes",
+        "_reached_fixedpoint",
+        "_sorted_nodes",
+        "_worklist",
     )
 
     def __init__(self):

angr/analyses/loop_analysis.py

@@ -19,7 +19,7 @@ class VariableTypes:
 
 
 class AnnotatedVariable:
-    __slots__ = ["variable", "type"]
+    __slots__ = ["type", "variable"]
 
     def __init__(self, variable, type_):
         self.variable = variable

angr/analyses/loopfinder.py

@@ -28,7 +28,7 @@ class Loop:
                     break
 
     def __repr__(self):
-        return "<Loop @ %s, %d blocks>" % (self.entry.addr, len(self.body_nodes))
+        return f"<Loop @ {self.entry.addr}, {len(self.body_nodes)} blocks>"
 
 
 class LoopFinder(Analysis):

angr/analyses/propagator/outdated_definition_walker.py

@@ -119,13 +119,19 @@ class OutdatedDefinitionWalker(AILBlockWalker):
             super()._handle_Load(expr_idx, expr, stmt_idx, stmt, block)
             # then if the address expression is up-to-date, we check the global store
             if not self.out_dated and (
-                self.state.global_stores
-                and not all(
-                    self._check_store_precedes_load(CodeLocation(store_block_addr, store_stmt_idx), self.expr_defat)
-                    for store_block_addr, store_stmt_idx, addr, store in self.state.global_stores
+                (
+                    self.state.global_stores
+                    and not all(
+                        self._check_store_precedes_load(CodeLocation(store_block_addr, store_stmt_idx), self.expr_defat)
+                        for store_block_addr, store_stmt_idx, addr, store in self.state.global_stores
+                    )
+                )
+                or (
+                    self.state.last_stack_store is not None
+                    and not self._check_store_precedes_load(
+                        CodeLocation(*self.state.last_stack_store[:2]), self.expr_defat
+                    )
                 )
-                or self.state.last_stack_store is not None
-                and not self._check_store_precedes_load(CodeLocation(*self.state.last_stack_store[:2]), self.expr_defat)
             ):
                 self.out_dated = True
 

angr/analyses/propagator/vex_vars.py

@@ -29,7 +29,7 @@ class VEXMemVar:
         return type(other) is VEXMemVar and other.addr == self.addr and other.size == self.size
 
     def __repr__(self):
-        return "<mem %#x[%d bytes]>" % (self.addr, self.size)
+        return f"<mem {self.addr:#x}[{self.size} bytes]>"
 
 
 class VEXReg(VEXVariable):
@@ -49,7 +49,7 @@ class VEXReg(VEXVariable):
         return type(other) is VEXReg and other.offset == self.offset and other.size == self.size
 
     def __repr__(self):
-        return "<reg %d[%d]>" % (self.offset, self.size)
+        return f"<reg {self.offset}[{self.size}]>"
 
 
 class VEXTmp(VEXVariable):
@@ -65,4 +65,4 @@ class VEXTmp(VEXVariable):
         return type(other) is VEXTmp and other.tmp == self.tmp
 
     def __repr__(self):
-        return "<tmp %d>" % self.tmp
+        return f"<tmp {self.tmp}>"

angr/analyses/reaching_definitions/__init__.py

@@ -24,21 +24,21 @@ if TYPE_CHECKING:
     from angr.storage.memory_mixins.paged_memory.pages import MVListPage
 
 __all__ = (
-    "LiveDefinitions",
-    "ObservationPointType",
-    "AtomKind",
     "Atom",
-    "Register",
-    "MemoryLocation",
-    "Tmp",
-    "GuardUse",
+    "AtomKind",
     "ConstantSrc",
     "Definition",
+    "FunctionCallData",
+    "FunctionHandler",
+    "GuardUse",
+    "LiveDefinitions",
+    "MemoryLocation",
+    "ObservationPointType",
     "ReachingDefinitionsAnalysis",
     "ReachingDefinitionsModel",
     "ReachingDefinitionsState",
-    "FunctionHandler",
-    "FunctionCallData",
+    "Register",
+    "Tmp",
     "get_all_definitions",
 )
 

angr/analyses/reaching_definitions/call_trace.py

@@ -7,9 +7,9 @@ class CallSite:
     """
 
     __slots__ = (
-        "caller_func_addr",
         "block_addr",
         "callee_func_addr",
+        "caller_func_addr",
     )
 
     def __init__(self, caller_func_addr: int, block_addr: int | None, callee_func_addr: int):
@@ -48,7 +48,7 @@ class CallTrace:
         self.callsites: list[CallSite] = []
 
     def __repr__(self):
-        return "<Trace with %d callsites>" % len(self.callsites)
+        return f"<Trace with {len(self.callsites)} callsites>"
 
     def current_function_address(self) -> int:
         if not self.callsites:

angr/analyses/reaching_definitions/function_handler_library/__init__.py

@@ -9,4 +9,4 @@ class LibcHandlers(LibcStdlibHandlers, LibcStdioHandlers, LibcUnistdHandlers, Li
     pass
 
 
-__all__ = ["EnvironAtom", "SystemAtom", "ExecveAtom", "StdoutAtom", "StdinAtom", "LibcHandlers"]
+__all__ = ["EnvironAtom", "ExecveAtom", "LibcHandlers", "StdinAtom", "StdoutAtom", "SystemAtom"]