Question regarding the source of gen_run.py

[nevercodecorrect]

Hi,
I am trying to setup the tool and test it. However, I encountered the below error in the trial execution
The command executed is lafleur --fusil-path /root/project-repo/fusil/fuzzers/fusil-python-threaded .
Based on the log, the tool finds the crash but failed to save the crashes eveytime due to the error of missing gen_run.py as shown in the below logs.

[*] Generating new seed with command: /root/project-repo/pyjitfuzz/jitfuzz-env/bin/python /root/project-repo/fusil/fuzzers/fusil-python-threaded --jit-fuzz --jit-target-uop=ALL --source-output-path=tmp_fuzz_run/gen_run.py --classes-number=0 --functions-number=1 --methods-number=0 --objects-number=0 --sessions=1 --python=/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python --no-jit-external-references --no-threads --no-async --jit-loop-iterations=300 --no-numpy --modules=encodings.ascii --only-generate
  [!!!] CRASH DETECTED! (EXIT:2). Saving...
  [!] Error saving crash artifacts: [Errno 2] No such file or directory: 'tmp_fuzz_run/gen_run.py'

After skimming the code, i only find gen_run.py referred in lafleur/corpus_manager.py:generate_new_seed(). Is this script auto generated or I missed certain steps?
Thanks for reading this.

[devdanzin]

Hi!

Yes, it's a generated seed file. The detected crash is just lafleur's handling of the missing file, not a real crash unfortunately.

I think lafleur may be having issues running the quoted command, maybe fusil is erroring out, maybe it's failing due to permission errors. Can you try directly running this command:

/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python /root/project-repo/fusil/fuzzers/fusil-python-threaded --jit-fuzz --jit-target-uop=ALL --source-output-path=tmp_fuzz_run/gen_run.py --classes-number=0 --functions-number=1 --methods-number=0 --objects-number=0 --sessions=1 --python=/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python --no-jit-external-references --no-threads --no-async --jit-loop-iterations=300 --no-numpy --modules=encodings.ascii --only-generate

? That should give us a clue.

Thanks for trying the project and raising this issue!

[nevercodecorrect]

Thanks a lot for the reply.
Directly running the given command, I get the below message

/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python /root/project-repo/fusil/fuzzers/fusil-python-threaded --jit-fuzz --jit-target-uop=ALL --source-output-path=tmp_fuzz_run/gen_run.py --classes-number=0 --functions-number=1 --methods-number=0 --objects-number=0 --sessions=1 --python=/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python --no-jit-external-references --no-threads --no-async --jit-loop-iterations=300 --no-numpy --modules=encodings.ascii --only-generate
Could not import tricky_numpy.
Traceback (most recent call last):
  File "/root/project-repo/fusil/fuzzers/fusil-python-threaded", line 38, in <module>
    from fusil.python import Fuzzer
  File "/root/project-repo/pyjitfuzz/jitfuzz-env/lib/python3.14/site-packages/fusil/python/__init__.py", line 7, in <module>
    from fusil.application import Application
  File "/root/project-repo/pyjitfuzz/jitfuzz-env/lib/python3.14/site-packages/fusil/application.py", line 7, in <module>
    from ptrace.error import PTRACE_ERRORS, writeError
ModuleNotFoundError: No module named 'ptrace'

It is kinda strange that fusil is installed but its dependency python-ptrace is missing. So I installed it again with sudo python setup.py install in fusil root dir again.
Then excuting the command again, I have the following output

/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python /root/project-repo/fusil/fuzzers/fusil-python-threaded --jit-fuzz --jit-target-uop=ALL --source-output-path=tmp_fuzz_run/gen_run.py --classes-number=0 --functions-number=1 --methods-number=0 --objects-number=0 --sessions=1 --python=/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python --no-jit-external-references --no-threads --no-async --jit-loop-iterations=300 --no-numpy --modules=encodings.ascii --only-generate
Could not import tricky_numpy.
Template strings available.
Numpy is not available.
3.14.2 (main, Feb  1 2026, 13:43:19) [GCC 11.4.0]
Fusil version 1.5 -- GNU GPL v2
https://github.com/devdanzin/fusil
Configuration error: Unable to get the identifier of the user 'fusil' and the group 'fusil' (create missing user/group or use --unsafe option)

Running time: 0:00:00.03
User time:    0:00:00.15

So I added unsafe in the command in the end again.

/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python /root/project-repo/fusil/fuzzers/fusil-python-threaded --jit-fuzz --jit-target-uop=ALL --source-output-path=tmp_fuzz_run/gen_run.py --classes-number=0 --functions-number=1 --methods-number=0 --objects-number=0 --sessions=1 --python=/root/project-repo/pyjitfuzz/jitfuzz-env/bin/python --no-jit-external-references --no-threads --no-async --jit-loop-iterations=300 --no-numpy --modules=encodings.ascii --only-generate --unsafe
Could not import tricky_numpy.
Template strings available.
Numpy is not available.
3.14.2 (main, Feb  1 2026, 13:43:19) [GCC 11.4.0]
Fusil version 1.5 -- GNU GPL v2
https://github.com/devdanzin/fusil

!!!WARNING!!! The fuzzer will run as user 0 and group 0,
!!!WARNING!!! and may remove arbitrary files and kill arbitrary processes.

Do you want to continue? (yes/NO) yes
Skip limiting memory to 524288000 bytes
Initial aggressivity: 1.0%
Debugger disabled
Use directory: /root/project-repo/pyjitfuzz/fuzzdir/python
Start time: Sun Feb  1 14:33:29 2026
Use python interpreter: /root/project-repo/pyjitfuzz/jitfuzz-env/bin/python
Python version: 3.14.2 (main, Feb  1 2026, 13:43:19) [GCC 11.4.0]
Found 1 Python modules
Use filenames: /etc/machine-id, /bin/sh

Running time: 0:00:06.36
User time:    0:00:00.14
[0][session 1] Start session (100.0%)
[!!!] ASTMutator not available, mutations will not happen. Install lafleur for mutations.
[0][session 1] Test module encodings.ascii
[0][session 1] 
Running time: 0:00:06.37
User time:    0:00:00.15
[0][session 1] Only generating Python source, skipping running it.
[0][session 1] Fusil log written into python/project.log
[0][session 1] 
Running time: 0:00:06.44
User time:    0:00:00.17

And gen_run.py is properly created with below content

# FUSIL_BOILERPLATE_START

from gc import collect
from random import choice, randint, random, sample, seed
from sys import stderr, path as sys_path
from os.path import dirname
import ast
import inspect
import io
import math
import operator
import time
import sys
from threading import Thread
from unittest.mock import MagicMock
import asyncio
seed(1026443187)

from string.templatelib import Interpolation, Template
print("Importing target module: encodings.ascii", file=stderr)
import encodings.ascii

TRIVIAL_TYPES = {int, str, float, bool, bytes, tuple, list, dict, set, type(None),}
def skip_trivial_type(obj_instance_or_class):
    if type(obj_instance_or_class) in TRIVIAL_TYPES:
        return True
    return False


import sys
from _collections import OrderedDict, deque
from abc import ABCMeta
from collections import Counter
from queue import Queue
from random import randint
from string import printable

try:
    from _decimal import Decimal
    has__decimal = True
except ImportError:
    from decimal import Decimal
    has__decimal = False

sequences = [Queue, deque, frozenset, list, set, str, tuple]
bytes_ = [bytearray, bytes]
numbers = [Decimal, complex, float, int]
dicts = [Counter, OrderedDict, dict]
# dicts = [OrderedDict, dict]
bases = sequences + bytes_ + numbers + dicts + [object]

large_num = 2**64
class WeirdBase(ABCMeta):
  def __hash__(self):
    return randint(0, large_num)

  def __eq__(self, other):
    return False


weird_instances = dict()
weird_classes = dict()
for cls in bases:
    class weird_cls(cls, metaclass=WeirdBase):
        def add(self, *args, **kwargs):
            pass
        append = clear = close = write = sort = reversed = add
        def encode(self, *args, **kwargs):
            return b""
        def decode(self, *args, **kwargs):
            return ""
        format = getvalue = join = read = replace = strip = rstrip = decode
        def get(self, *args, **kwargs):
            return self
        open = pop = update = get
        def readlines(self, *args, **kwargs):
            return [""]
        rsplit = split = partition = rpartition = readlines
        def items(self):
            return {}.items()
        def keys(self):
            return {}.keys()
        def values(self):
            return {}.values()

    weird_cls.__name__ = f"weird_{cls.__name__}"
    weird_instances[f"weird_{cls.__name__}_empty"] = weird_cls()
    weird_classes[f"weird_{cls.__name__}"] = weird_cls

tricky_strs = (chr(0), chr(127), chr(255), chr(0x10FFFF), "𝒜","\\x00" * 10, "A" * (2 ** 16), "💻" * 2**10,)

# We cannot create a Decimal larger than 10 ** 4300 with _pydecimal, only with _decimal
max_str_digits_adjustment = 1 if has__decimal else -1
big_int_for_decimal = 10 ** (sys.int_info.default_max_str_digits + max_str_digits_adjustment)

for cls in sequences:
    weird_instances[f"weird_{cls.__name__}_single"] = weird_classes[f"weird_{cls.__name__}"]("a")
    weird_instances[f"weird_{cls.__name__}_range"] = weird_classes[f"weird_{cls.__name__}"](range(20))
    weird_instances[f"weird_{cls.__name__}_types"] = weird_classes[f"weird_{cls.__name__}"](bases)
    weird_instances[f"weird_{cls.__name__}_printable"] = weird_classes[f"weird_{cls.__name__}"](printable)
    weird_instances[f"weird_{cls.__name__}_special"] = weird_classes[f"weird_{cls.__name__}"](tricky_strs)
for cls in bytes_:
    weird_instances[f"weird_{cls.__name__}_bytes"] = weird_classes[f"weird_{cls.__name__}"](b"abcdefgh_" * 10)
for cls in numbers:
    weird_instances[f"weird_{cls.__name__}_sys_maxsize"] = weird_classes[f"weird_{cls.__name__}"](sys.maxsize)
    weird_instances[f"weird_{cls.__name__}_sys_maxsize_minus_one"] = weird_classes[f"weird_{cls.__name__}"](sys.maxsize - 1)
    weird_instances[f"weird_{cls.__name__}_sys_maxsize_plus_one"] = weird_classes[f"weird_{cls.__name__}"](sys.maxsize + 1)
    weird_instances[f"weird_{cls.__name__}_neg_sys_maxsize"] = weird_classes[f"weird_{cls.__name__}"](-sys.maxsize)
    weird_instances[f"weird_{cls.__name__}_2**63-1"] = weird_classes[f"weird_{cls.__name__}"](2 ** 63 - 1)
    weird_instances[f"weird_{cls.__name__}_2**63"] = weird_classes[f"weird_{cls.__name__}"](2 ** 63)
    weird_instances[f"weird_{cls.__name__}_2**63+1"] = weird_classes[f"weird_{cls.__name__}"](2 ** 63 + 1)
    weird_instances[f"weird_{cls.__name__}_-2**63+1"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 63 + 1)
    weird_instances[f"weird_{cls.__name__}_-2**63"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 63)
    weird_instances[f"weird_{cls.__name__}_-2**63-1"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 63 -1)
    weird_instances[f"weird_{cls.__name__}_2**31-1"] = weird_classes[f"weird_{cls.__name__}"](2 ** 31 - 1)
    weird_instances[f"weird_{cls.__name__}_2**31"] = weird_classes[f"weird_{cls.__name__}"](2 ** 31)
    weird_instances[f"weird_{cls.__name__}_2**31+1"] = weird_classes[f"weird_{cls.__name__}"](2 ** 31 + 1)
    weird_instances[f"weird_{cls.__name__}_-2**31+1"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 31 + 1)
    weird_instances[f"weird_{cls.__name__}_-2**31"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 31)
    weird_instances[f"weird_{cls.__name__}_-2**31-1"] = weird_classes[f"weird_{cls.__name__}"](-2 ** 31 - 1)
    if cls not in (float, complex) and hasattr(sys, 'int_info'):
        weird_instances[f"weird_{cls.__name__}_10**default_max_str_digits+1"] = weird_classes[f"weird_{cls.__name__}"](big_int_for_decimal)
for cls in dicts:
    weird_instances[f"weird_{cls.__name__}_basic"] = weird_classes[f"weird_{cls.__name__}"]({a: a for a in range(100)})
    weird_instances[f"weird_{cls.__name__}_tricky_strs"] = weird_classes[f"weird_{cls.__name__}"]({a: a for a in tricky_strs})


# Class with a __del__ side effect to attack the JIT optimizer
class FrameModifier:
    def __init__(self, var_name, new_value):
        # Store the name of the variable to target and its new value.
        self.var_name = var_name
        self.new_value = new_value
        # Announce creation for debugging the generated script
        print(f"  [FrameModifier created to target '{self.var_name}']", file=sys.stderr)

    def __del__(self):
        try:
            # On destruction, get the calling frame (1 level up).
            frame = sys._getframe(1)
            # Maliciously modify the local variable in that frame.
            print(f"  [Side Effect] In __del__: Modifying '{self.var_name}' to {self.new_value!r}", file=sys.stderr)
            if self.var_name in frame.f_locals:
                frame.f_locals[self.var_name] = self.new_value
            elif self.var_name.split(".")[0] in frame.f_locals and self.var_name.count(".") == 1:  # instance_or_class.attribute
                instance_or_class_str, attr_str = self.var_name.split(".")
                setattr(frame.f_locals[instance_or_class_str], attr_str, self.new_value)
            else:  # module.instance_or_class.attribute
                module_str, instance_or_class_str, attr_str = self.var_name.split(".")
                instance_or_class = getattr(frame.f_locals[module_str], instance_or_class_str)
                setattr(instance_or_class, attr_str, self.new_value)
        except Exception as e:
            # Frame inspection can be tricky; don't crash in __del__.
            print(f"  [Side Effect] Error in FrameModifier.__del__: {e}", file=sys.stderr)


import abc
import builtins
import collections.abc
import itertools
import types
import typing
from functools import reduce
from operator import or_

abc_types = [cls for cls in abc.__dict__.values() if isinstance(cls, type)]
builtins_types = [cls for cls in builtins.__dict__.values() if isinstance(cls, type)]
collections_abc_types = [cls for cls in collections.abc.__dict__.values() if isinstance(cls, type)]
collections_types = [cls for cls in collections.__dict__.values() if isinstance(cls, type)]
itertools_types = [cls for cls in itertools.__dict__.values() if isinstance(cls, type)]
types_types = [cls for cls in types.__dict__.values() if isinstance(cls, type)]
typing_types = [cls for cls in typing.__dict__.values() if isinstance(cls, type)]

all_types = (abc_types + builtins_types + collections_abc_types + collections_types + itertools_types
             + types_types + typing_types)
all_types = [t for t in all_types if not (isinstance(t, type) and issubclass(t, BaseException))]
big_union = reduce(or_, all_types, int)


import types
import inspect
import itertools
tricky_cell = types.CellType(None)
tricky_simplenamespace = types.SimpleNamespace(dummy=None, cell=tricky_cell)
tricky_simplenamespace.dummy = tricky_simplenamespace
tricky_capsule = types.CapsuleType
tricky_module = types.ModuleType("tricky_module", "docs")
tricky_module2 = types.ModuleType("tricky_module2\\x00", "docs\\x00")
try:
    tricky_genericalias = types.GenericAlias(list, (int,))
except AttributeError:
    tricky_genericalias = None

tricky_dict = {}
if tricky_capsule: tricky_dict[tricky_capsule] = tricky_cell
if tricky_module: tricky_dict[tricky_module] = tricky_genericalias
tricky_dict["tricky_dict"] = tricky_dict
tricky_mappingproxy = types.MappingProxyType(tricky_dict)


def tricky_function(*args, **kwargs):
    if len(args) > 150: raise RecursionError("Fuzzer controlled depth")
    a = 1
    def b(x=a):
        v = x
        return v
    return tricky_function(*(args + (1,)), **kwargs)


tricky_lambda = lambda *args, **kwargs: tricky_lambda(*args, **kwargs)
tricky_classmethod = classmethod(tricky_lambda)
tricky_staticmethod = staticmethod(tricky_lambda)
tricky_property = property(tricky_lambda)
tricky_code = tricky_lambda.__code__
tricky_closure = tricky_function.__code__.co_freevars
tricky_classmethod_descriptor = types.ClassMethodDescriptorType # This is the type itself


class TrickyDescriptor:
    def __get__(self, obj, objtype=None):
        return self
    def __set__(self, obj, value):
        try:
            obj.__dict__["_value_descriptor"] = value
        except AttributeError:
            pass
    def __delete__(self, obj):
        try:
            del obj.__dict__["_value_descriptor"]
        except (AttributeError, KeyError):
            pass


class TrickyMeta(type):
    @property
    def __signature__(self):
        raise AttributeError("Signature denied by TrickyMeta")
    def __mro_entries__(self, bases):
        return (object,)
        #return super().__mro_entries__(bases)


class TrickyClass(metaclass=TrickyMeta):
    tricky_descriptor = TrickyDescriptor()

    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)

    def __init__(self, *args, **kwargs):
        self._value_init = None

    def __getattr__(self, name):
        if name == "crash_on_getattr": raise ValueError("getattr manipulated")
        return self


tricky_instance = TrickyClass()
try:
    tricky_frame = inspect.currentframe()
    if tricky_frame: # currentframe() can be None
        # tricky_frame.f_builtins.update(tricky_dict)
        tricky_frame.f_globals.update(tricky_dict)
        tricky_frame.f_locals.update(tricky_dict)
except RuntimeError:
    tricky_frame = None


try:
    1 / 0
except ZeroDivisionError as e:
    tricky_traceback = e.__traceback__
else:
    tricky_traceback = None


# tricky_generator = (x for x in itertools.count())
tricky_list_with_cycle = [[]] * 6 + []
tricky_list_with_cycle[0].append(tricky_list_with_cycle)
tricky_list_with_cycle[-1].append(tricky_list_with_cycle)
tricky_list_with_cycle.append(tricky_list_with_cycle)
if tricky_list_with_cycle[0] and tricky_list_with_cycle[0][0] is tricky_list_with_cycle:
    tricky_list_with_cycle[0][0].append(tricky_list_with_cycle)


def errback(*args, **kw):
    raise ValueError('errback called')


class Liar1:
    def __eq__(self, other):
        return True

class Liar2:
    def __eq__(self, other):
        return False

liar1, liar2 = Liar1(), Liar2()

class Evil:
    def __eq__(self, other):
        for attr in dir(other):
            try: other.__dict__[attr] = errback
            except: pass

evil = Evil()


# Define a custom exception to distinguish our check from others.
class JITCorrectnessError(AssertionError): pass


# This function is called only once, so it will not be JIT-compiled.
def no_jit_harness(func, *args, **kwargs):
    return func(*args, **kwargs)

# This function calls its target in a loop to make it 'hot' for the JIT.
def jit_harness(func, iterations, *args, **kwargs):
    print(f"[+] Warming up {func.__name__} for {iterations} iterations...", file=stderr)
    for _ in range(iterations):
        func(*args, **kwargs)
    print("[+] Warm-up complete.", file=stderr)

# Helper for correctness testing that handles NaN, lambdas, and complex numbers.
import math
import types
def compare_results(a, b):
    if isinstance(a, types.FunctionType) and a.__name__ == '<lambda>' and \
       isinstance(b, types.FunctionType) and b.__name__ == '<lambda>':
        return True # Treat two lambdas as equal for our purposes
    if isinstance(a, complex) and isinstance(b, complex):
        a_real_nan = math.isnan(a.real)
        b_real_nan = math.isnan(b.real)
        a_imag_nan = math.isnan(a.imag)
        b_imag_nan = math.isnan(b.imag)
        real_match = (a.real == b.real) or (a_real_nan and b_real_nan)
        imag_match = (a.imag == b.imag) or (a_imag_nan and b_imag_nan)
        return real_match and imag_match
    if isinstance(a, float) and isinstance(b, float) and math.isnan(a) and math.isnan(b):
        return True
    if isinstance(a, object) and isinstance(b, object):
        return True
    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b):
        return all(compare_results(x, y) for x, y in zip(a, b))
    return a == b

SENTINEL_VALUE = object()

def callMethod(prefix, obj_to_call, method_name, *arguments, verbose=True):
    func_display_name = f"encodings.ascii.{method_name}()" if obj_to_call is encodings.ascii else f"{obj_to_call.__class__.__name__}.{method_name}()"
    message = f"[{prefix}] {func_display_name}"
    if verbose:
        print(message, file=stderr)
    result = SENTINEL_VALUE
    try:
        func_to_run = getattr(obj_to_call, method_name)
        for _ in range(int(3)):
            result = func_to_run(*arguments)
    except (Exception, SystemExit, KeyboardInterrupt) as err:
        try:
            errmsg = repr(err)
        except Exception as e_repr:
            errmsg = f'Error during repr: {e_repr.__class__.__name__}'
        errmsg = errmsg.encode('ASCII', 'replace').decode('ASCII')
        if verbose:
            print(f"[{prefix}] {func_display_name} => EXCEPTION: {err.__class__.__name__}: {errmsg}", file=stderr)
        result = SENTINEL_VALUE
    if verbose:
        print(f"[{prefix}] -explicit garbage collection-", file=stderr)
    collect()
    return result

def callFunc(prefix, func_name_str, *arguments, verbose=True):
    return callMethod(prefix, encodings.ascii, func_name_str, *arguments, verbose=verbose)

fuzz_target_module = encodings.ascii



# FUSIL_BOILERPLATE_END


import sys
from random import choice, randint, random, sample
from sys import stderr, path as sys_path


print("--- Fuzzing 1 functions in encodings.ascii ---", file=stderr)
print("[f1] JIT-TARGET-UOP=ALL: Randomly selected uops: ['_DELETE_ATTR', '_DELETE_ATTR', '_COMPARE_OP_GT_STR', '_COMPARE_OP_EQ_INT', '_BUILD_SET', '_COMPARE_OP_GT_INT', '_UNARY_NOT']", file=stderr)

print("[f1] STRATEGY: Targeted Uop Fuzzing (['_DELETE_ATTR', '_DELETE_ATTR', '_COMPARE_OP_GT_STR', '_COMPARE_OP_EQ_INT', '_BUILD_SET', '_COMPARE_OP_GT_INT', '_UNARY_NOT'])", file=stderr)
# --- Setup for uop: ALL ---
object_with_attr_v1 = -35427331869229

int_v2 = 866

str_v3 = "\uDB52\u8C33"

str_v4 = "\uC9A0\u8A0E\u815E\u44B0\u7AC2\uEE46\u0365\uCFDD\u2A6E\u9615\u10FE\u69C5\u6657\u127E\uB5E9\u6196\u3F31\u727F\uB65C\u9A08"

unstable_hash_object_v5 = -347.2

stateful_index_object_v6 = "\uF77A\u2732\u5225\uF1B5\uFD25\uC9C0\uDF1F\u30F3\uBF6C\u882B\u5C67\u01EF\u4FDB\uA8CF\u6955\u9254"

# This harness function contains the synthesized code.
def uop_harness_f1():
    # --- Core Pattern ---
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    try:
        del object_with_attr_v1.x
    except AttributeError:
        pass
    object_with_attr_v1.x = int_v2
    str_v3 > str_v4
    str_v3 > str_v4
    str_v3 > str_v4
    str_v3 > str_v4
    str_v3 > str_v4
    int_v2 == int_v2
    int_v2 == int_v2
    int_v2 == int_v2
    int_v2 == int_v2
    int_v2 == int_v2
    {unstable_hash_object_v5, unstable_hash_object_v5}
    {unstable_hash_object_v5, unstable_hash_object_v5}
    {unstable_hash_object_v5, unstable_hash_object_v5}
    {unstable_hash_object_v5, unstable_hash_object_v5}
    {unstable_hash_object_v5, unstable_hash_object_v5}
    int_v2 > int_v2
    int_v2 > int_v2
    int_v2 > int_v2
    not stateful_index_object_v6
    not stateful_index_object_v6
    not stateful_index_object_v6

# Execute the harness in a JIT-warming hot loop.
for i_f1 in range(300):
    try:
        uop_harness_f1()
    except Exception as e:
        print(f"EXCEPTION: {e.__class__.__name__}: {e}", file=stderr)
        break
        pass

print("[f1] Targeted Uop Fuzzing (['_DELETE_ATTR', '_DELETE_ATTR', '_COMPARE_OP_GT_STR', '_COMPARE_OP_EQ_INT', '_BUILD_SET', '_COMPARE_OP_GT_INT', '_UNARY_NOT']) done.", file=stderr)

print("--- Fuzzing 6 classes in encodings.ascii ---", file=stderr)

I assume it is created properly?
BTW, I also see several warnings regarding numpy, tricky_numpy and ASTMutator not available. Are these expected?

[devdanzin]

Sorry about the sorry state fusil is in, it needs some love to make installing more robust and avoiding all those warnings.

Yes, the file is created properly, you should be able to run lafleur now that fusil is generating the necessary seed files.

These warnings are expected. I should avoid emitting them in the first place, thanks for asking!

[nevercodecorrect]

Thanks a lot! Really appreciate your help.