diff --git a/crates/rusty_alloc/CHANGELOG.md b/crates/rusty_alloc/CHANGELOG.md index 6178b10..5da82e7 100644 --- a/crates/rusty_alloc/CHANGELOG.md +++ b/crates/rusty_alloc/CHANGELOG.md @@ -7,6 +7,105 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Fixed + +- **A cross-thread double free could hang the next collect instead of + aborting.** The README says a double free aborts "on both the local and the + cross-thread path". The cross-thread arm of that check lived in + `page_collect` and compared the drained chain's length against `used` — + AFTER walking the chain. A block freed twice from another thread is linked + onto `xthread_free` twice, which makes the chain CYCLIC, so the walk never + reached the compare: the owner's next collect, or on an abandoned page the + next reclaim, spun forever, and nothing aborted. Now `remote_free` refuses a + block that is already the chain head — one compare on the cross-thread arm, + and the local path is byte-identical, checked on the x86-64 release + assembly for Windows and Linux — and the collect walk is bounded by `used`, + so the interleaved case (A, B, A) aborts on the first collect instead of + hanging. Four child-process regressions in `tests/double_free.rs` (a block + abandoned by a dying thread; `set_default_heap` then exit; a first-class + heap then exit; interleaved A-B-A), green under `secure`, `blockmap` and + both. Found by the Openheimer campaign as OH-rusty_alloc-11, whose log + claimed a fix that had never been written. +- **Thread exit abandoned only the heap in `done_slot`.** A first-class heap + never `heap_delete`d before its thread exited, or one installed with + `set_default_heap`, stayed DELAYED under a dead owner: its blocks could be + freed any number of times onto a delayed list no thread would ever drain, + and a thread that only ever called `create_heap` had no exit hook at all. + `create_heap` now bootstraps the thread first and exit abandons every heap + the thread still owns; upstream deletes non-backing heaps at thread exit + for the same reason (OH-rusty_alloc-13). +- **Integer wraps a caller could reach with a size, alignment, offset or + option value, all on cold paths:** `malloc(usize::MAX)` overflowed + `header + size` in `huge_alloc`; a huge `offset` to `malloc_aligned_at` or + `realloc_aligned_at` wrapped `p + offset` (debug panic, release wild + pointer); guarded `malloc(MAX)` wrapped `payload + page`; `os::page_align_up` + and `os::alloc_aligned` on an unrepresentable size or a garbage alignment; + `bin_size` of a garbage index; `page_under_utilized` with a huge percentage; + `options::get_size` KiB scaling; `get_clamp` with inverted bounds; + `reserve_huge_os_pages` `pages * 1 GiB`; `prim::fixed::dedicated_segments` + and `region_for` at `usize::MAX`; `segment_map::register_range` within one + window of the top of the address space (the window walk is bounded); + `subproc_new` exhaustion and `subproc_add_current_thread` out of range, + which were `assert!`s on public entries; and `is_aligned_to(x, 0)`, which + was true for every `x`. Each returns null, `Err`, `false` or a refused id + instead (OH-rusty_alloc-5, 6, 8, 9, 10, 14, 18–21, 28–34, 42–45). +- **`manage_os_memory` adopted anything it was handed.** Null, a range that + wrapped, an unmapped address, or a window this allocator already owns all + became an arena, and the next default `malloc` wrote a `Segment` header + there. The range must now be non-null, non-wrapping, mapped (`mincore` / + `VirtualQuery` behind `prim::range_is_reserved`) and not already a + registered window; a real OS reservation still adopts. `arena_register` + claims its slot with a CAS and frees the descriptor and the mapping when + refused; `chunk_alloc_n(0)` is `None`, and `chunk_free_n` / `chunk_free` + refuse a count past the bitmap or an interior pointer instead of releasing + a live chunk (OH-rusty_alloc-12, 15, 22, 25, 27, 201, 202). +- **Hook re-entry.** A deferred-free, error or output hook that allocated, + printed or errored re-entered itself until the stack was gone; each hook + now runs under a thread-local in-hook flag (OH-rusty_alloc-17, 23, 24). +- **`--release --features debug_checks` did not check.** The foreign-pointer + guard was a `debug_assert!` inside the `debug_checks` cfg, compiled out of + the one build a consumer enables the feature for. It is an `assert!` + (OH-rusty_alloc-7). `malloc_small` / `zalloc_small` forward an oversize + request instead of `debug_assert!`ing on it (OH-62). +- **OS wrappers on a lie.** `prim::alloc` with a garbage alignment and + `prim::commit` of null are `Err`; the latter used to hand Windows an + untracked mapping (OH-rusty_alloc-38, 60). +- **C ABI.** `mi_dupenv_s` / `mi_wdupenv_s` clear the caller's out-pointers + on EINVAL as the CRT contract says; `mi_realpath` never writes past + `PATH_MAX`; every out-parameter write refuses a null or misaligned pointer; + a null, misaligned or immortal-empty heap handle is "no heap" for every + `mi_heap_*` entry rather than a dereference, and `mi_heap_set_default` + refuses such a handle instead of installing it (OH-rusty_alloc-16, 26, 54, + 58, 65, 66, 97–102). + +### Changed + +- **What was NOT taken from the Openheimer campaign, and why.** The + campaign's log carries 202 findings; 139 of them are one probe — an + internal `unsafe fn` handed null, `0x1`, or an address just past a + constant "floor" — chased through 25 helpers and up a ladder of floors + (`0x1000`, `0x10000`, `SEGMENT_SIZE`, then 2×, 3×, 4× that) and finally + answered with a segment-map membership lookup on every internal handle: + `page_of`, `page_index`, `page_area`, `free_local`, `retire_emptied`, + `box_of_xheap` (a registry walk under a global lock, on the free path) and + twenty more. Those guards validated contracts the caller inside this crate + already upholds, duplicated the residual the threat model accepts for `free` + (R-001: release `free` trusts its pointer's window), and taxed the hot path + — `free` +27, `realloc` +164, `page_extend` +68 instructions when the + campaign stopped, which it never measured. None of it landed. What did: + every check on a value a caller can actually choose — sizes, counts, + alignments, offsets, option values, out-pointers, C strings, heap handles at + the C ABI, `manage_os_memory` ranges — on paths that are cold or, for + `free`, cost the local path nothing. x86-64 release assembly against 2.2.0, + Windows / Linux: `free` +4 / +4 (both on the cross-thread arm; no frame), + `malloc` 0 / 0, `malloc_aligned_at` 0 / 0, `realloc` +7 / +6, + `realloc_aligned_at` +1 / +1, `page_extend` 0 / 0, `usable_size` 0 / 0. + The disposition, finding by finding, is `docs/plans/openheimer-run.md`. +- `bins::is_aligned_to` spells its power-of-two test as + `align & (align - 1) == 0` rather than `is_power_of_two()`: without `popcnt` + in the target features the latter was emitted as a 20-instruction SWAR bit + count inside `realloc_aligned_at` (+43 on that function, now +1). + ## [2.2.0](https://github.com/Remade-With-Rust/rusty_alloc/compare/rusty_alloc-v2.1.0...rusty_alloc-v2.2.0) - 2026-09-10 ### Fixed diff --git a/crates/rusty_alloc/UNSAFE.md b/crates/rusty_alloc/UNSAFE.md index 73c1dd1..8518a7e 100644 --- a/crates/rusty_alloc/UNSAFE.md +++ b/crates/rusty_alloc/UNSAFE.md @@ -10,7 +10,7 @@ Census basis: `unsafe` occurrences in CODE per file (comments stripped; `unsafe fn` signatures and the four `unsafe impl`s included). **The baseline is now MACHINE-ENFORCED** (H-11): `tools/unsafe-census.sh` counts `unsafe` in code (comments stripped) per file against -`tools/unsafe-baseline.txt` — **903 occurrences across 23 files, 2026-09-09** +`tools/unsafe-baseline.txt` — **928 occurrences across 23 files, 2026-09-16** — and FAILS if the total grows. Growth is not forbidden, it is required to be deliberate: add the new sites here with their purpose and audit date, then re-run with `--update` in the same commit. `cargo geiger`, the registry's @@ -21,17 +21,17 @@ unsafe in DEPENDENCIES, and ours are `libc` plus bindings-only `windows-sys`. | Module | Count | What the `unsafe` is for | Last audit | |---|---:|---|---| | `alloc.rs` | 94 | The public entry points: raw-pointer reads on the malloc fast path (must never form `&mut` on the shared empty-heap sentinel), pointer-derived metadata on the free path (`segment_of`/`page_of`), block-content copies in the realloc family. **+15 on 2026-08-22**: the free path's two `asm!` sites — the memory-destination `used--` whose flags drive the retire branch (its `label` block is a separate item and carries its own `unsafe`), and the fused `cmp {tid}, fs:0` in both `free_inline` and `free_general` — plus `malloc_or`/`malloc_or_slow`, which give `operator new` a fast path whose miss is a tail call. Each asm reads or writes exactly one field it already had a valid pointer to; none widens what the surrounding code could already touch | 2026-08-22 (free campaign; every new block reviewed at the site) | -| `heap.rs` | 71 | Owner-thread page/queue manipulation under raw pointers (no two `&mut Page` may coexist), the aligned-allocation peek, span carving. **+3 on 2026-08-19**: `try_unlink_huge_segment` split out of `remove_huge_segment`. **+15 on 2026-08-22**: `malloc_generic` split into a small entry plus `malloc_generic_walk`, with `grow_front`, `try_guarded` and `drain_delayed` as cold arms — each split adds an `unsafe fn` signature and its block while dereferencing nothing the single function did not — and the immortal `EMPTY_DELAYED` sentinel that lets the heartbeat read its list without a null test. **+2 on 2026-09-07 (P4e, §2.15 of `docs/plans/small-metal.md`)**: the reclamation fixes — one `unsafe` for the periodic `generic_collect` sweep and one for the reclaim-and-retry that runs before `malloc_generic` returns null. Both call `collect_inner`, which allocates nothing and touches only this heap’s own pages on the owner thread; each carries its SAFETY line. `malloc_generic` itself became a safe wrapper over the renamed `malloc_generic_once`, so the split added no signature. **+2 on 2026-09-08:** the medium collect-and-retry ahead of the heartbeat -- one `unsafe` around `page_collect` + `page_pop` on the bin queue front, one reading `free_is_zero` off the page just popped. Both are the SAME operations `malloc_generic_walk` performs on the same page a few lines later, on the owner thread under the heap lock: the block moves earlier, nothing new is dereferenced. Each carries its SAFETY line | 2026-09-08 | -| `init.rs` | 37 | Thread/heap lifecycle: the initial-exec TLS slot (`global_asm!` + fs-relative asm reads), thread-pointer register reads (`fs:0`/`gs:0x30`/`tpidrro_el0`), heap-box creation/teardown, the abandonment path run inside platform TLS destructors. **+1 on 2026-09-09 (`firmware-what-is-left.md` §7.3): an ATTRIBUTE, not an operation** — `unsafe(link_section = ".rodata.…")` on `EMPTY_HEAP_BOX`, bare metal only, so the never-written sentinel lives in flash instead of costing 1,752 bytes of RAM. The token is counted because the census is a text search; the contract it rests on (raw reads only, no page ever stores its address) is the one the `Sync` impl below already carries, and a write would now fault against the flash cache instead of silently landing. `create_heap`'s template copy from it is a `ptr::read` inside the block that already existed | 2026-09-09 | +| `heap.rs` | 71 | Owner-thread page/queue manipulation under raw pointers (no two `&mut Page` may coexist), the aligned-allocation peek, span carving. **+3 on 2026-08-19**: `try_unlink_huge_segment` split out of `remove_huge_segment`. **+15 on 2026-08-22**: `malloc_generic` split into a small entry plus `malloc_generic_walk`, with `grow_front`, `try_guarded` and `drain_delayed` as cold arms — each split adds an `unsafe fn` signature and its block while dereferencing nothing the single function did not — and the immortal `EMPTY_DELAYED` sentinel that lets the heartbeat read its list without a null test. **+2 on 2026-09-07 (P4e, §2.15 of `docs/plans/small-metal.md`)**: the reclamation fixes — one `unsafe` for the periodic `generic_collect` sweep and one for the reclaim-and-retry that runs before `malloc_generic` returns null. Both call `collect_inner`, which allocates nothing and touches only this heap’s own pages on the owner thread; each carries its SAFETY line. `malloc_generic` itself became a safe wrapper over the renamed `malloc_generic_once`, so the split added no signature. **+2 on 2026-09-08:** the medium collect-and-retry ahead of the heartbeat -- one `unsafe` around `page_collect` + `page_pop` on the bin queue front, one reading `free_is_zero` off the page just popped. Both are the SAME operations `malloc_generic_walk` performs on the same page a few lines later, on the owner thread under the heap lock: the block moves earlier, nothing new is dereferenced. Each carries its SAFETY line. **+2 on 2026-09-16 (Openheimer):** the two refuse arms in `malloc_aligned_at_slow` when `bins::aligned_at_from` reports that `block + offset + align` would wrap for a caller-chosen offset — each is one `free_local` of the block just allocated on this thread, which has not escaped | 2026-09-16 | +| `init.rs` | 42 | Thread/heap lifecycle: the initial-exec TLS slot (`global_asm!` + fs-relative asm reads), thread-pointer register reads (`fs:0`/`gs:0x30`/`tpidrro_el0`), heap-box creation/teardown, the abandonment path run inside platform TLS destructors. **+1 on 2026-09-09 (`firmware-what-is-left.md` §7.3): an ATTRIBUTE, not an operation** — `unsafe(link_section = ".rodata.…")` on `EMPTY_HEAP_BOX`, bare metal only, so the never-written sentinel lives in flash instead of costing 1,752 bytes of RAM. The token is counted because the census is a text search; the contract it rests on (raw reads only, no page ever stores its address) is the one the `Sync` impl below already carries, and a write would now fault against the flash cache instead of silently landing. `create_heap`'s template copy from it is a `ptr::read` inside the block that already existed. **+5 on 2026-09-16 (Openheimer, OH-rusty_alloc-13):** thread exit now abandons EVERY heap the dying thread still owns, not only the one in `done_slot` — a first-class heap that was never `heap_delete`d, or one installed with `set_default_heap`, used to stay DELAYED under a dead owner forever. `take_heap_owned_by` unlinks one such box under `HEAPS_LOCK` (one block: the registry walk); `thread_done` reads `owner_tid` off its own box and calls the split-out `unsafe fn thread_done_one` for the primary box and for each extra one (three sites plus the signature). Nothing new is dereferenced that the single function did not; each carries its SAFETY line | 2026-09-16 | | `segment.rs` | 35 | Segment/page metadata addressing: the mask trick (`segment_of`), `page_of`'s contract-based indexing — **the bound is now PROVED for every in-segment offset by `proofs.rs` (Kani), not merely asserted** — span tiling, purge/recommit | 2026-08-19 | -| `prim/windows.rs` | 30 | OS FFI: VirtualAlloc family, FLS destructors, QPC, BCryptGenRandom | 2026-08-08 (0.4.0) | +| `prim/windows.rs` | 33 | OS FFI: VirtualAlloc family, FLS destructors, QPC, BCryptGenRandom. **+3 on 2026-09-16 (Openheimer):** `range_is_reserved` (`zeroed` `MEMORY_BASIC_INFORMATION` + `VirtualQuery`, the same OS answer `unix.rs` gets from `mincore`), and `alloc_aligned` now refuses a garbage alignment and a `size + align` that wraps BEFORE it reserves anything, and releases a re-reservation that the OS placed anywhere but the aligned address it asked for instead of returning it misaligned (`VirtualFree`, one block) | 2026-09-16 | | `page.rs` | 38 | Free-list links written into dead blocks, the lock-free `xthread_free` four-state protocol (loom-modeled in `tests/loom_xthread.rs`), the immortal `EMPTY_PAGE` sentinel — **+1 on 2026-09-09: the same `unsafe(link_section)` attribute as `init.rs`, placing it in flash on bare metal; its free list is permanently null, so nothing writes it**. **+8 on 2026-08-22**: `page_link_local` split out of `page_push_local` so the caller can decrement `used` in one memory-destination RMW, `page_collect_impl` const-generic over whether it also writes the protocol flag, and `USED_OFFSET` — whose value is asserted against `offset_of!(Page, used)` by a unit test, because an asm operand is not type-checked and a field reordering would silently decrement the wrong bytes | 2026-08-22 (free campaign) | -| `prim/unix.rs` | 27 | OS FFI: mmap family, madvise/decommit, pthread keys, /dev/urandom | 2026-08-08 (0.4.0 Darwin decommit fix) | +| `prim/unix.rs` | 28 | OS FFI: mmap family, madvise/decommit, pthread keys, /dev/urandom. **+1 on 2026-09-16 (Openheimer, OH-201):** `range_is_reserved` asks `mincore` whether a caller-supplied `manage_os_memory` range is mapped at all before it becomes an arena — one FFI call on a page-aligned probe | 2026-09-16 | | `prim/mod.rs` | 18 | The `TlsSlot` abstraction (`unsafe impl Send/Sync`, justified at the impls), dispatch to the platform backends | 2026-08-08 | | `rusty_alloc_api/src/lib.rs` | 14 | The `GlobalAlloc`/`Allocator` impls forwarding layouts to the core; `unsafe` is inherent to those traits' contracts | 2026-08-19 | | `os.rs` | 12 | The prim-layer wrapper: commit/decommit/protect plumbing | 2026-08-08 | | `prim/mock.rs` | 8 | Miri-only mock OS backend (never shipped; `cfg(miri)`) | 2026-08-06 | -| `arena.rs` | 8 | Lock-free chunk bitmap claim/verify, recycled-chunk scrubbing (the 0.1.0-alpha.2 UAF fix lives here: `wait_no_remote_in_flight` on every recycle path) | 2026-08-08 | +| `arena.rs` | 15 | Lock-free chunk bitmap claim/verify, recycled-chunk scrubbing (the 0.1.0-alpha.2 UAF fix lives here: `wait_no_remote_in_flight` on every recycle path). The baseline had drifted to 13 without a row edit; recorded now. **+2 on 2026-09-16 (Openheimer, `docs/plans/openheimer-run.md`):** `arena_register` claims its slot with a CAS instead of a load-then-store, and the two new blocks are the REFUSE arm — `os::free` of the descriptor and of the OS mapping when the table is full or the slot was lost — so a refused arena leaks nothing. Both free memory this function allocated a few lines earlier and nothing else has seen; each carries its SAFETY line | 2026-09-16 | | `prim/fixed.rs` | 37 | **New 2026-09-07 (P1 of `docs/plans/small-metal.md`).** The fixed-region backend for a target with no OS: memory is a `&'static mut [u8]` handed over once. **6 of the 18 are `unsafe fn` signatures the prim seam requires** (`alloc`/`free`/`commit`/`decommit`/`reset`/`protect`) whose *bodies contain no unsafe operation at all* — the free list is `AtomicUsize` arrays under a spin lock and the pointers are built with the safe `with_exposed_provenance_mut`, so this backend adds **zero** unsafe dereferences to the shipped crate. The other 12 are in `#[cfg(test)]`: two `&raw mut` static-region handoffs and ten calls through the `unsafe fn` seam, each with its SAFETY line. **+1 on 2026-09-07 (P2):** the region test became two-sided — where the shipped geometry refuses a segment-sized request from a 512 KiB region, the small profile SERVES one, so the test now frees it too. Audited at the site; the module is `allow(dead_code)` and unreachable on every platform that has an arm above it. **+7 on 2026-09-07 (P4b, §2.9/§2.10 of the same plan):** the two-ended `place` rule added ZERO unsafe to shipped code — `place` is a pure arithmetic `fn` and the scan around it is unchanged — and all seven are in `#[cfg(test)]`: one `slice::from_raw_parts_mut` carving the `REGION_ALIGN`-aligned window out of `BACKING` (replacing a `&mut *ptr` that a `repr(align(65536))` static would have needed, which rustc 1.97.1 on MSVC cannot compile), one `ptr::add` to reach that window, and five calls through the `unsafe fn` seam in the placement assertions and in `greedy_segments`, which allocates segments until refusal and frees every one before returning. Each carries its SAFETY line **+1 on 2026-09-09 (morning, `#21`):** the two-sided alignment test frees the SEGMENT_SIZE-aligned page it is served when the region straddles a boundary — `#[cfg(test)]`, banked without a row here at the time; recorded now. **+5 on 2026-09-09 (`docs/plans/finished/region-alignment-bug.md` §7): the module ships its first unsafe OPERATIONS.** (1) `unsafe impl Sync for Region` and (2) the `&mut *self.bytes.get()` in `Region::give` — the once-only handoff the Janus seam has carried since 2.0.0, moved here so the alignment travels with it; a module-wide `REGION_GIVEN` swap precedes the `&mut`, so a second `give` on any instance is refused before it could alias. (3) `unsafe impl Sync for FirstHeapBox`, the bare-metal static holding the first heap's descriptor (handed out once by `take_first_heap_box`, on the one thread such a build has). The other two are `#[cfg(test)]`: a `from_raw_parts_mut` carving the report's misaligned base out of a static for the refusal probe, and a `Box::new_zeroed().assume_init()` allocating a `Region` in place, because materialising a 64 KiB-aligned value on the stack first faults on Windows. Each carries its SAFETY line. **+2 on 2026-09-09 (`docs/plans/finished/region-alignment-dissolve.md`): zero new unsafe in shipped code** — segments now stride from the region's base, and every piece of that is safe: `stride_base` is a relaxed load, `place` takes an `origin` and does arithmetic, `install_region` aligns the base up. The two are `#[cfg(test)]`, the `--cfg ra_aligned_region` arm of the two-sided alignment test (an `alloc` and a `free` through the `unsafe fn` seam: the 2.0.4 straddle case, kept under the knob that restores the mask), and the `Box::new_zeroed().assume_init()` moved under that same cfg — the default arm is a plain `static Region` now, which a 16-byte-aligned type can be on every host toolchain. Each carries its SAFETY line. **+4 on 2026-09-09 (`docs/plans/finished/esp32-large-alloc-ceiling.md`): all four are `#[cfg(test)]`, and shipped code gained none.** The large-allocation ceiling reported from `rusty_zstd` is reproduced against the real extent allocator by `greedy_dedicated`, which serves `huge_alloc`-shaped reservations until the region refuses and frees every one before returning (two calls through the `unsafe fn` seam), plus one `alloc`/`free` pair modelling the whole segment a first small allocation claims. The fix itself -- the `ra_segment_size` geometry knob, `dedicated_segments`, `region_for_allocs` and `region_capacity` -- is arithmetic over the existing atomics and adds no unsafe operation at all. Each carries its SAFETY line | 2026-09-09 | | `prim/wasm.rs` | 6 | `memory.grow` linear-memory backend | 2026-08-06 | | `options.rs` | 6 | Env parsing at init, registered-hook invocation | 2026-08-06 | @@ -50,7 +50,7 @@ comment, and all four are in the H-11 ratchet's baseline. | Module | Count | What the `unsafe` is for | Last audit | |---|---:|---|---| -| `rusty_alloc_ffi/src/lib.rs` | 350 | **The workspace's untrusted boundary**: 157 `extern "C"` entry points receiving caller pointers and sizes. Every out-parameter writer null-guards; `mi_posix_memalign` validates alignment (power of two, ≥ `sizeof(void*)`) and returns EINVAL/ENOMEM; all 8 `count × size` sites use `checked_mul`. Panics cannot unwind into C (edition 2024 aborts on `extern "C"` unwind; release is `panic = "abort"`). **+2 on 2026-08-22**: `new_impl` routes through `alloc::malloc_or` so the OOM arm is a tail call rather than a null test that keeps `size` live | 2026-08-22 | +| `rusty_alloc_ffi/src/lib.rs` | 350 | **The workspace's untrusted boundary**: 157 `extern "C"` entry points receiving caller pointers and sizes. Every out-parameter writer null-guards; `mi_posix_memalign` validates alignment (power of two, ≥ `sizeof(void*)`) and returns EINVAL/ENOMEM; all 8 `count × size` sites use `checked_mul`. Panics cannot unwind into C (edition 2024 aborts on `extern "C"` unwind; release is `panic = "abort"`). **+2 on 2026-08-22**: `new_impl` routes through `alloc::malloc_or` so the OOM arm is a tail call rather than a null test that keeps `size` live. **+6 on 2026-09-16 (Openheimer, `docs/plans/openheimer-run.md`):** `heap_ptr` — one `unsafe fn` plus its deref — is now the ONE place a C heap handle is turned into a `Heap`, after a null / misaligned / immortal-empty-box check (shape only: what a well-formed handle points at is the caller's, as for `free`); and `mi_dupenv_s` / `mi_wdupenv_s` write null and 0 through the caller's out-pointers on the EINVAL path (four writes) instead of leaving them untouched, as the CRT contract says. Every out-parameter write in the crate goes through `out_mut`, which refuses null and misaligned pointers; the 64 KiB address floor it briefly carried is gone, because it would have refused legitimate out-pointers on wasm32, where static data starts at 1 KiB | 2026-09-16 | | `rusty_alloc_override/src/lib.rs` | 51 | `malloc`/`free`/`operator new` interposition for `LD_PRELOAD` — thin forwarding to `alloc::*`, plus the `free_inline` export that carries the fast-path body. No state of its own. **+2 on 2026-08-22**: the sized-delete exports follow the same `free_inline` shape as the unsized ones | 2026-08-22 | | `rusty_alloc_bench/src/*.rs` | 29 | Tier-B kernels and the `.ratrace` replayer. The trace parser's `unwrap`s are infallible by TYPE (`Record::decode` takes `&[u8; RECORD_SIZE]`), and the one genuinely-invalid field returns `InvalidData` | 2026-08-20 (first audit) | | `rusty_alloc_wasm/src/lib.rs` | 21 | The `ra_selftest` cdylib fixture: raw block writes and read-back checks that prove the wasm build actually allocates | 2026-08-20 (first audit) | diff --git a/crates/rusty_alloc/src/alloc.rs b/crates/rusty_alloc/src/alloc.rs index b9ba73a..106a871 100644 --- a/crates/rusty_alloc/src/alloc.rs +++ b/crates/rusty_alloc/src/alloc.rs @@ -135,11 +135,16 @@ fn my_heap() -> *mut Heap { /// What it buys: every test, every Miri run, every fuzz iteration and every /// debug-built consumer now turns "mysterious corruption later" into "this /// pointer was not ours, at this call". That is where the bug is findable. +/// +/// The check is `assert!`, not `debug_assert!`. A `debug_assert!` inside this +/// cfg compiles OUT of `--release --features debug_checks`, which made the +/// feature vacuous in exactly the build a consumer enables it for +/// (OH-rusty_alloc-7). #[inline(always)] fn debug_foreign_pointer_guard(p: *mut u8) { #[cfg(any(debug_assertions, feature = "debug_checks"))] { - debug_assert!( + assert!( crate::segment_map::contains(p), "rusty_alloc: free() called on a pointer this allocator never returned \ ({p:p} is not in any registered segment window). A foreign pointer here \ @@ -406,15 +411,15 @@ pub fn mallocn(count: usize, size: usize) -> *mut u8 { } } -/// Small-size fast entry (`mi_malloc_small`): caller guarantees ≤ 1 KiB. +/// Small-size fast entry (`mi_malloc_small`): the caller promises ≤ 1 KiB. +/// An oversize request is a full `malloc`, not a `debug_assert!` — this is a +/// public entry, and `heap_malloc_small` already forwarded (OH-rusty_alloc-62). pub fn malloc_small(size: usize) -> *mut u8 { - debug_assert!(size <= SMALL_SIZE_MAX); malloc(size) } -/// Zeroed small-size fast entry (`mi_zalloc_small`). +/// Zeroed small-size fast entry (`mi_zalloc_small`). As [`malloc_small`]. pub fn zalloc_small(size: usize) -> *mut u8 { - debug_assert!(size <= SMALL_SIZE_MAX); zalloc(size) } @@ -642,7 +647,7 @@ pub unsafe fn realloc_aligned_at( let usable = unsafe { usable_size(p) }; if newsize <= usable && newsize >= usable / 2 - && crate::bins::is_aligned_to(p.addr() + offset, align) + && crate::bins::is_aligned_at(p.addr(), offset, align) { stat_realloc(true); return p; @@ -715,7 +720,7 @@ pub unsafe fn rezalloc_aligned_at( let usable = unsafe { usable_size(p) }; if newsize <= usable && newsize >= usable / 2 - && crate::bins::is_aligned_to(p.addr() + offset, align) + && crate::bins::is_aligned_at(p.addr(), offset, align) { stat_realloc(true); return p; diff --git a/crates/rusty_alloc/src/arena.rs b/crates/rusty_alloc/src/arena.rs index e837e7a..d140764 100644 --- a/crates/rusty_alloc/src/arena.rs +++ b/crates/rusty_alloc/src/arena.rs @@ -97,13 +97,25 @@ fn arena_register( (*a).owned = owned; (*a).numa_node = numa_node; } - let id = ARENA_COUNT.fetch_add(1, Ordering::AcqRel); - if id >= MAX_ARENAS { - ARENA_COUNT.fetch_sub(1, Ordering::AcqRel); - return Err(()); + // CAS so `ARENA_COUNT` never exceeds `MAX_ARENAS` (no transient `ARENAS[32]` + // window for `arena_area`, and the overflow path frees the descriptor + // instead of leaking it). + loop { + let id = ARENA_COUNT.load(Ordering::Acquire); + if id >= MAX_ARENAS { + // SAFETY: `desc` is the descriptor mapping allocated above and + // never published (no `ARENAS` slot names it). + let _ = unsafe { os::free(desc) }; + return Err(()); + } + if ARENA_COUNT + .compare_exchange(id, id + 1, Ordering::AcqRel, Ordering::Acquire) + .is_ok() + { + ARENAS[id].store(a, Ordering::Release); + return Ok(id as i32); + } } - ARENAS[id].store(a, Ordering::Release); - Ok(id as i32) } /// `mi_reserve_os_memory_ex`: reserve (and commit) fresh OS memory as an @@ -126,11 +138,24 @@ pub fn reserve_os_memory_ex( if crate::FIXED_REGION { return Err(()); } - let total = size.div_ceil(SEGMENT_SIZE) * SEGMENT_SIZE; + // Unsatisfiable size (e.g. usize::MAX) is Err, not `chunks * SEGMENT_SIZE` + // overflow (OH-rusty_alloc-12). + let chunks = size.div_ceil(SEGMENT_SIZE); + let Some(total) = chunks.checked_mul(SEGMENT_SIZE) else { + return Err(()); + }; // Eager commit (our segment model); `_commit=false` still reserves+commits // in v1 — recorded divergence, matches how segments consume chunks. let b = os::alloc_aligned(total, SEGMENT_SIZE, true, allow_large).map_err(|_| ())?; - arena_register(b.ptr, total, exclusive, true, -1) + match arena_register(b.ptr, total, exclusive, true, -1) { + Ok(id) => Ok(id), + Err(()) => { + // SAFETY: `b` is the reservation made two lines up; a refused + // register never recorded it, so nothing else can reach it. + let _ = unsafe { os::free(b) }; + Err(()) + } + } } /// `mi_manage_os_memory_ex`: adopt caller-provided memory (never freed by us). @@ -154,12 +179,33 @@ pub fn manage_os_memory_ex( if crate::FIXED_REGION { return Err(()); } - let lo_addr = (start.addr() + SEGMENT_SIZE - 1) & !(SEGMENT_SIZE - 1); - let hi = (start.addr() + size) & !(SEGMENT_SIZE - 1); + // Null / overflowing ranges are Err, not `addr + size` debug overflow or a + // registry covering the address space (OH-rusty_alloc-15). Whether the + // range is real memory is the OS's answer (`range_is_reserved`, below), + // not an address floor's. + if start.is_null() { + return Err(()); + } + let Some(end) = start.addr().checked_add(size) else { + return Err(()); + }; + let Some(lo_raw) = start.addr().checked_add(SEGMENT_SIZE - 1) else { + return Err(()); + }; + let lo_addr = lo_raw & !(SEGMENT_SIZE - 1); + let hi = end & !(SEGMENT_SIZE - 1); if hi <= lo_addr { return Err(()); } let lo = start.with_addr(lo_addr); + let span = hi - lo_addr; + // A window we already named is live heap, not caller memory + // (OH-rusty_alloc-202). An unmapped lie must not become an arena + // (OH-rusty_alloc-201) — the next default malloc would write a Segment + // there. + if crate::segment_map::contains(lo) || !crate::os::range_is_reserved(lo, span) { + return Err(()); + } // Conservative: treat managed memory as dirty (not-zero) — the dirty // bitmap starts clear, so mark it at first alloc instead; simplest is to // pre-mark every chunk dirty. @@ -340,6 +386,11 @@ pub fn chunk_alloc_n(restrict_id: i32, n: usize) -> Option<(*mut u8, bool)> { if crate::FIXED_REGION { return None; } + if n == 0 { + // Zero chunks is None, not `run == 0` on a used bit handing out a + // pointer with no claim (OH-rusty_alloc-22). + return None; + } if n == 1 { return chunk_alloc(restrict_id); } @@ -442,6 +493,11 @@ pub fn chunk_free_n(p: *mut u8, n: usize) -> bool { if crate::FIXED_REGION { return false; // nothing came from an arena, so nothing returns to one } + // Zero / overflowing `n` is false, not `start..start+n` OOB on the bitmap + // (OH-rusty_alloc-25). + if n == 0 { + return false; + } let addr = p.addr(); let count = ARENA_COUNT.load(Ordering::Acquire).min(MAX_ARENAS); for id in 0..count { @@ -449,17 +505,35 @@ pub fn chunk_free_n(p: *mut u8, n: usize) -> bool { if a.is_null() { continue; } - // SAFETY: live descriptor; bounded indices per the range check. + // SAFETY: live descriptor; indices clamped to live chunks. unsafe { - if addr >= (*a).base.addr() - && addr < (*a).base.addr() + (*a).chunks_live.load(Ordering::Acquire) * SEGMENT_SIZE - { - let start = (addr - (*a).base.addr()) / SEGMENT_SIZE; - for j in start..start + n { - (*a).used[j / WORD_BITS].fetch_and(!(1 << (j % WORD_BITS)), Ordering::AcqRel); - } - return true; + let chunks = (*a).chunks_live.load(Ordering::Acquire); + let Some(span) = chunks.checked_mul(SEGMENT_SIZE) else { + continue; + }; + let Some(end_addr) = (*a).base.addr().checked_add(span) else { + continue; + }; + if addr < (*a).base.addr() || addr >= end_addr { + continue; } + let off = addr - (*a).base.addr(); + // Interior pointers are false, not a successful free of the + // containing chunk (OH-rusty_alloc-27). + if !off.is_multiple_of(SEGMENT_SIZE) { + return false; + } + let start = off / SEGMENT_SIZE; + let Some(end) = start.checked_add(n) else { + return false; + }; + if end > chunks { + return false; + } + for j in start..end { + (*a).used[j / WORD_BITS].fetch_and(!(1 << (j % WORD_BITS)), Ordering::AcqRel); + } + return true; } } false @@ -480,10 +554,21 @@ pub fn chunk_free(p: *mut u8) -> bool { } // SAFETY: live descriptor; bit index bounded by the range check. unsafe { - if addr >= (*a).base.addr() - && addr < (*a).base.addr() + (*a).chunks_live.load(Ordering::Acquire) * SEGMENT_SIZE - { - let idx = (addr - (*a).base.addr()) / SEGMENT_SIZE; + let chunks = (*a).chunks_live.load(Ordering::Acquire); + let Some(span) = chunks.checked_mul(SEGMENT_SIZE) else { + continue; + }; + let Some(end_addr) = (*a).base.addr().checked_add(span) else { + continue; + }; + if addr >= (*a).base.addr() && addr < end_addr { + let off = addr - (*a).base.addr(); + // Interior pointers are false, not a successful free of the + // containing chunk (OH-rusty_alloc-27). + if !off.is_multiple_of(SEGMENT_SIZE) { + return false; + } + let idx = off / SEGMENT_SIZE; (*a).used[idx / WORD_BITS].fetch_and(!(1 << (idx % WORD_BITS)), Ordering::AcqRel); return true; } @@ -589,7 +674,9 @@ pub(crate) fn adopt_os_block(ptr: *mut u8, size: usize) -> Option { /// `mi_arena_area`: the arena's base and size, or null. pub fn arena_area(id: i32) -> (*mut u8, usize) { - if crate::FIXED_REGION || id < 0 || id as usize >= ARENA_COUNT.load(Ordering::Acquire) { + // Index by the table bound, not a count that can race past it + // (`ARENAS` is `MAX_ARENAS` slots). + if crate::FIXED_REGION || id < 0 || (id as usize) >= MAX_ARENAS { return (ptr::null_mut(), 0); } let a = ARENAS[id as usize].load(Ordering::Acquire); @@ -598,10 +685,8 @@ pub fn arena_area(id: i32) -> (*mut u8, usize) { } // SAFETY: live descriptor. unsafe { - ( - (*a).base, - (*a).chunks_live.load(Ordering::Acquire) * SEGMENT_SIZE, - ) + let chunks = (*a).chunks_live.load(Ordering::Acquire); + ((*a).base, chunks.checked_mul(SEGMENT_SIZE).unwrap_or(0)) } } diff --git a/crates/rusty_alloc/src/bins.rs b/crates/rusty_alloc/src/bins.rs index 6fbefb3..8b360f2 100644 --- a/crates/rusty_alloc/src/bins.rs +++ b/crates/rusty_alloc/src/bins.rs @@ -42,13 +42,23 @@ pub fn bin(size: usize) -> usize { #[inline] pub const fn bin_size(bin: usize) -> usize { if bin <= 8 { - bin * INTPTR_SIZE - } else { - // bin = (b<<2) + m - 3 with block wsize = (5+m) << (b-2) - let t = bin + 3; - let b = t >> 2; - let m = t & 3; - ((5 + m) << (b - 2)) * INTPTR_SIZE + return bin * INTPTR_SIZE; + } + // Garbage indices (`usize::MAX`) are 0, not `bin + 3` debug overflow or a + // wrapping shift into a tiny class (OH-rusty_alloc-32). Meaningless for + // [`BIN_HUGE`]/[`BIN_FULL`] as before; those still take this arm when + // they fit the formula. + let Some(t) = bin.checked_add(3) else { + return 0; + }; + let b = t >> 2; + if b < 2 { + return 0; + } + let shift = b - 2; + match (5 + (t & 3)).checked_shl(shift as u32) { + Some(w) => w.saturating_mul(INTPTR_SIZE), + None => 0, } } @@ -76,10 +86,43 @@ pub fn good_size(size: usize) -> usize { /// is the CONSERVATIVE answer at every call site — each one falls back to the /// general path rather than taking an in-place or same-bin shortcut. A mask /// alone would be unsound there (`4 & (3-1) == 0` says "aligned to 3"). +/// +/// `align == 0` is not a power of two, so this returns `false`. Do **not** +/// lift zero to 1 first: that made every address report as aligned-to-zero +/// (Openheimer `oh_f04_is_aligned_to_is_total`, 2026-09-15) while +/// `malloc_aligned(_, 0)` correctly returns null. #[inline(always)] pub fn is_aligned_to(x: usize, align: usize) -> bool { - let a = align.max(1); - a.is_power_of_two() && (x & (a - 1)) == 0 + // The power-of-two test is spelled out rather than `is_power_of_two()`: + // that is a popcount, and without `popcnt` in the target features LLVM + // emitted it as a 20-instruction SWAR bit count inside + // `realloc_aligned_at` (measured 2026-09-16). `align & (align - 1) == 0` + // is the same predicate in three instructions, and `align != 0` keeps + // zero out — `0 & MAX == 0` would otherwise admit it (OH-rusty_alloc-5). + let m = align.wrapping_sub(1); + align != 0 && align & m == 0 && x & m == 0 +} + +/// `(addr + offset)` is aligned to `align`. Overflow of the add is `false`, +/// not a debug panic (OH-rusty_alloc-42 / OH-43). +#[inline] +pub fn is_aligned_at(addr: usize, offset: usize, align: usize) -> bool { + match addr.checked_add(offset) { + Some(s) => is_aligned_to(s, align), + None => false, + } +} + +/// First address `p >= base` such that `(p + offset) % align == 0`. +/// +/// `None` when the add overflows. Wrapping here would hand out a wild +/// interior pointer; the callers refuse with null instead (OH-rusty_alloc-6). +#[inline] +pub(crate) fn aligned_at_from(base: usize, offset: usize, align: usize) -> Option { + debug_assert!(align.is_power_of_two() && align > 0); + let sum = base.checked_add(offset)?.checked_add(align - 1)?; + let rounded = sum & !(align - 1); + rounded.checked_sub(offset) } /// `ceil(2^32 / odd)` for the four odd parts a bin size can have, indexed by @@ -187,6 +230,14 @@ pub(crate) fn exact_div_by_block_size(n: usize, bsize: usize) -> usize { mod tests { use super::*; + #[test] + fn aligned_at_from_refuses_overflow() { + assert!(aligned_at_from(0x1000, usize::MAX, 8).is_none()); + assert_eq!(aligned_at_from(0x1000, 16, 64), Some(0x1030)); + assert_eq!(bin_size(usize::MAX), 0); + assert_eq!(bin_size(0), 0); + } + #[test] fn bin_size_inverts_bin() { // For every bin reachable from a size, bin_size must be the largest diff --git a/crates/rusty_alloc/src/heap.rs b/crates/rusty_alloc/src/heap.rs index 92c1cfb..d735615 100644 --- a/crates/rusty_alloc/src/heap.rs +++ b/crates/rusty_alloc/src/heap.rs @@ -930,8 +930,17 @@ impl Heap { fn guarded_alloc(&mut self, size: usize) -> (*mut u8, bool) { let ps = crate::os::page_size(); let payload = crate::os::page_align_up(size.max(1)); + // An unsatisfiable payload (`page_align_up` saturated, or the guard + // page does not fit) is null, not `payload + page` wrapped into a + // small guarded object. + if payload < size.max(1) { + return (ptr::null_mut(), false); + } + let Some(need) = payload.checked_add(ps) else { + return (ptr::null_mut(), false); + }; // huge_alloc gives us a dedicated segment with a page-aligned block. - let (block, _z) = self.huge_alloc(payload + ps, ps, 0); + let (block, _z) = self.huge_alloc(need, ps, 0); if block.is_null() { return (ptr::null_mut(), false); } @@ -1096,7 +1105,11 @@ impl Heap { // immortal empty-page sentinel; reading `free` is the same access // `page_pop` performs. let b = unsafe { (*p).free }; - if !b.is_null() && b.addr() & (align - 1) == 0 { + // `wrapping_sub`: `align == 0` reaches this peek (the power-of-two + // test admits it), and the mask must then be `usize::MAX` — which + // fails for any non-null `b` and takes the refusing slow path — + // not a debug overflow. Identical release codegen. + if !b.is_null() && b.addr() & align.wrapping_sub(1) == 0 { // SAFETY: as `Heap::malloc` — pop from this thread's own page. let b = unsafe { crate::page::page_pop(p) }; debug_assert!(!b.is_null()); @@ -1174,7 +1187,19 @@ impl Heap { if block.is_null() { return (ptr::null_mut(), false); } - let p = block.with_addr(((block.addr() + offset + align - 1) & !(align - 1)) - offset); + // `block + offset + align` can wrap for a caller-chosen offset: that + // is an unsatisfiable request, and the block goes back, not out. + let Some(addr) = bins::aligned_at_from(block.addr(), offset, align) else { + // SAFETY: `block` was just allocated on this thread and has not escaped. + unsafe { self.free_local(block) }; + return (ptr::null_mut(), false); + }; + if addr < block.addr() { + // SAFETY: as the overflow arm — block is ours and has not escaped. + unsafe { self.free_local(block) }; + return (ptr::null_mut(), false); + } + let p = block.with_addr(addr); debug_assert!((p.addr() + offset).is_multiple_of(align)); if p != block { // SAFETY: block is ours, just allocated on this thread; marking @@ -1831,7 +1856,10 @@ impl Heap { unsafe { let pg = segment::page_of(seg, p); page_collect(pg); - ((*pg).used as usize) * 100 < ((*pg).capacity as usize) * perc + // Saturating: a huge caller `perc` is "always under", not a debug + // overflow or a wrapped comparison. + ((*pg).used as usize).saturating_mul(100) + < ((*pg).capacity as usize).saturating_mul(perc) } } diff --git a/crates/rusty_alloc/src/init.rs b/crates/rusty_alloc/src/init.rs index a9ef24b..c9673aa 100644 --- a/crates/rusty_alloc/src/init.rs +++ b/crates/rusty_alloc/src/init.rs @@ -200,6 +200,35 @@ fn heaps_unregister(hb: *mut HeapBox) { heaps_unlock(); } +/// Unlink and return one live heap box owned by `tid`, or null. +/// +/// The lock is released before return so the caller can abandon the heap +/// without re-entering `HEAPS_LOCK` (abandon walks pages and can allocate). +fn take_heap_owned_by(tid: usize) -> *mut HeapBox { + heaps_lock(); + let mut prev: *mut HeapBox = ptr::null_mut(); + let mut cur = HEAPS_HEAD.load(Ordering::Relaxed); + while !cur.is_null() { + // SAFETY: links and boxes are live under the lock. + unsafe { + let nxt = (*cur).next_box.load(Ordering::Relaxed); + if (*cur).owner_tid == tid { + if prev.is_null() { + HEAPS_HEAD.store(nxt, Ordering::Relaxed); + } else { + (*prev).next_box.store(nxt, Ordering::Relaxed); + } + heaps_unlock(); + return cur; + } + prev = cur; + cur = nxt; + } + } + heaps_unlock(); + ptr::null_mut() +} + /// Storage for the calling thread's default-heap pointer. /// /// On x86-64 Linux this is a RAW ELF TLS symbol reached with the @@ -545,6 +574,19 @@ pub fn ensure_heap(hb: *mut HeapBox) -> *mut HeapBox { /// upstream returns NULL from `mi_heap_new` for the same reason (H-18/R-003 /// in the hardening audit). pub fn create_heap(tag: i32, allow_destroy: bool, arena_id: i32) -> *mut HeapBox { + // First-class heaps are not stored in `done_slot`. A thread that only + // ever called `mi_heap_new` / `heap_malloc` never ran `init_thread_heap`, + // so the TLS destructor never fired and leftover heaps stayed DELAYED + // (OH-rusty_alloc-13). Bootstrap the backing heap (and the exit hook) + // first. `init_thread_heap` calls `create_heap_uninstalled`, not this + // function, so there is no recursion. + if !crate::ONE_THREAD && heap_tls::get() == empty_heap_box_ptr() { + let _ = heap_box(); + } + create_heap_uninstalled(tag, allow_destroy, arena_id) +} + +fn create_heap_uninstalled(tag: i32, allow_destroy: bool, arena_id: i32) -> *mut HeapBox { let size = core::mem::size_of::(); // On a one-region target the FIRST descriptor is a static of the fixed // backend's, so that a firmware's region is whole segments and needs no @@ -627,7 +669,7 @@ pub fn create_heap(tag: i32, allow_destroy: bool, arena_id: i32) -> *mut HeapBox #[cold] fn init_thread_heap() -> *mut HeapBox { - let hb = create_heap(0, false, -1); + let hb = create_heap_uninstalled(0, false, -1); if hb.is_null() { // OOM: install nothing — the TLS slot keeps the sentinel, so the // NEXT allocation retries creation instead of dereferencing null. @@ -732,6 +774,41 @@ unsafe extern "C" fn thread_done_cb(v: *mut c_void) { /// # Safety /// Must run on the dying thread with `hb` its live heap box, exactly once. pub unsafe fn thread_done(hb: *mut HeapBox) { + // SAFETY: per contract `hb` is this thread's live box; `owner_tid` is a + // plain field. + let tid = unsafe { (*hb).owner_tid }; + // SAFETY: per contract we are the owner and this runs exactly once; + // sequencing per the model. + unsafe { thread_done_one(hb) }; + // Back to the SENTINEL, not null — the slot is never null, so a + // post-teardown malloc re-enters the generic path and re-initialises. + heap_tls::set(empty_heap_box_ptr()); + // First-class heaps this thread created are not stored in `done_slot` + // (`set_default_heap` does not update it). Leaving them DELAYED meant a + // second remote free after thread exit returned (OH-rusty_alloc-13). + // Abandon every remaining heap we still own so pages go NEVER. Iterative: + // a dying thread can own many first-class heaps; do not recurse. + if !crate::ONE_THREAD { + // Stall guard: a dying thread that keeps re-initialising (empty TLS + // malloc) must not loop forever. Same order as `collect_inner`'s + // `MAX_RECLAIM`. + const MAX_OWNED_HEAPS: usize = 1 << 20; + for _ in 0..MAX_OWNED_HEAPS { + let extra = take_heap_owned_by(tid); + if extra.is_null() { + break; + } + // SAFETY: extra is a live box this dying thread still owns. + unsafe { thread_done_one(extra) }; + } + } +} + +/// Abandon one heap box (NEVER + delayed drain + unregister + free the box). +/// +/// # Safety +/// `hb` is a live heap box owned by the calling thread, not used again. +unsafe fn thread_done_one(hb: *mut HeapBox) { // SAFETY: per contract we are the owner; sequencing per the model. unsafe { // Read the subprocess tag from the BOX, not from `my_subproc()`. We are @@ -831,9 +908,6 @@ pub unsafe fn thread_done(hb: *mut HeapBox) { let _ = os::free(blockdesc); } } - // Back to the SENTINEL, not null — the slot is never null, so a - // post-teardown malloc re-enters the generic path and re-initialises. - heap_tls::set(empty_heap_box_ptr()); } /// `mi_heap_delete`: free the heap structure, MIGRATING its live pages and @@ -1008,10 +1082,21 @@ pub fn subproc_main() -> usize { } /// `mi_subproc_new`: allocate a fresh subprocess id. +/// +/// Exhaustion is an invalid id (`MAX_SUBPROCS`), not an assert (OH-rusty_alloc-21). pub fn subproc_new() -> usize { - let id = SUBPROC_NEXT.fetch_add(1, Ordering::AcqRel); - assert!(id < MAX_SUBPROCS, "out of subprocess ids"); - id + loop { + let id = SUBPROC_NEXT.load(Ordering::Acquire); + if id >= MAX_SUBPROCS { + return MAX_SUBPROCS; + } + if SUBPROC_NEXT + .compare_exchange_weak(id, id + 1, Ordering::AcqRel, Ordering::Acquire) + .is_ok() + { + return id; + } + } } /// `mi_subproc_delete`: ids are not recycled in v1; abandoned segments of the @@ -1036,7 +1121,9 @@ pub fn subproc_delete(id: usize) { /// `mi_subproc_add_current_thread`. pub fn subproc_add_current_thread(id: usize) { - assert!(id < MAX_SUBPROCS); + if id >= MAX_SUBPROCS { + return; + } SUBPROC.with(|c| c.set(id)); // Mirror onto this thread's backing heap so TEARDOWN can read the tag // without touching the thread-local (see `HeapBox::subproc`). Tagging diff --git a/crates/rusty_alloc/src/options.rs b/crates/rusty_alloc/src/options.rs index 58191d5..7b38cc7 100644 --- a/crates/rusty_alloc/src/options.rs +++ b/crates/rusty_alloc/src/options.rs @@ -7,6 +7,7 @@ //! option access. Values follow mimalloc: booleans accept 1/0/true/false/ //! yes/no/on/off; sizes are plain integers (`_size` options are KiB). +use core::cell::Cell; use core::ffi::c_void; use core::sync::atomic::{AtomicBool, AtomicPtr, Ordering}; @@ -428,15 +429,20 @@ pub fn is_enabled(option: usize) -> bool { } /// `mi_option_get_clamp`. +/// +/// Inverted bounds (`min > max`) are swapped, not a panic from `i64::clamp` +/// (OH-rusty_alloc-18). pub fn get_clamp(option: usize, min: i64, max: i64) -> i64 { - get(option).clamp(min, max) + get(option).clamp(min.min(max), min.max(max)) } /// `mi_option_get_size`: `_size` options are stored in KiB. pub fn get_size(option: usize) -> usize { let v = get(option).max(0) as usize; match option { - 9 | 23 => v * 1024, // reserve_os_memory, arena_reserve + // Overflow is "unrepresentable", not a wrapped small reserve + // (OH-rusty_alloc-19). + 9 | 23 => v.saturating_mul(1024), _ => v, } } @@ -470,6 +476,22 @@ static ERROR_FUN: AtomicUsize2 = AtomicUsize2::new(); static DEFERRED_FUN: AtomicUsize2 = AtomicUsize2::new(); static HEARTBEAT: AtomicU64 = AtomicU64::new(0); +ra_thread_local! { + static IN_DEFERRED: Cell = const { Cell::new(false) }; + static IN_ERROR: Cell = const { Cell::new(false) }; + static IN_OUTPUT: Cell = const { Cell::new(false) }; +} + +/// Re-arms one of the in-hook flags above on scope exit, so a hook that +/// returns early — or unwinds, in a debug build — still clears its guard. +struct HookExit(fn()); + +impl Drop for HookExit { + fn drop(&mut self) { + (self.0)(); + } +} + /// (fn ptr, arg) pair stored as two atomics (registration is set-once-ish; /// tearing between the two reads yields a stale-but-valid pair). struct AtomicUsize2 { @@ -539,6 +561,13 @@ pub fn out_fmt(msg: &str) { } return; } + // A hook that calls `out_fmt` again recurses until the stack dies + // (OH-rusty_alloc-24). + if IN_OUTPUT.with(|c| c.get()) { + return; + } + IN_OUTPUT.with(|c| c.set(true)); + let _clear = HookExit(|| IN_OUTPUT.with(|c| c.set(false))); // NUL-terminate on the stack for the C hook (bounded copy). let bytes = msg.as_bytes(); let mut buf = [0u8; 512]; @@ -604,6 +633,12 @@ pub fn deferred_free(force: bool) { if DEFERRED_FUN.load_fun().is_null() { return; } + // A hook that allocates re-enters `malloc_generic` → `deferred_free`. + // Without a per-thread guard that recurses until the stack dies + // (OH-rusty_alloc-17). + if IN_DEFERRED.with(|c| c.get()) { + return; + } fire_deferred(force); } @@ -617,6 +652,8 @@ pub fn deferred_free(force: bool) { #[cold] #[inline(never)] fn fire_deferred(force: bool) { + IN_DEFERRED.with(|c| c.set(true)); + let _clear = HookExit(|| IN_DEFERRED.with(|c| c.set(false))); let (f, a) = DEFERRED_FUN.load(); if !f.is_null() { let hb = HEARTBEAT.fetch_add(1, Ordering::Relaxed); @@ -632,6 +669,13 @@ fn fire_deferred(force: bool) { pub fn error(err: i32) { let (f, a) = ERROR_FUN.load(); if !f.is_null() { + // A hook that calls `error` again recurses until the stack dies + // (OH-rusty_alloc-23). + if IN_ERROR.with(|c| c.get()) { + return; + } + IN_ERROR.with(|c| c.set(true)); + let _clear = HookExit(|| IN_ERROR.with(|c| c.set(false))); // SAFETY: registered with the documented signature. unsafe { let fun: ErrorFun = core::mem::transmute::<*mut c_void, ErrorFun>(f); diff --git a/crates/rusty_alloc/src/os.rs b/crates/rusty_alloc/src/os.rs index a9827cf..ab683fa 100644 --- a/crates/rusty_alloc/src/os.rs +++ b/crates/rusty_alloc/src/os.rs @@ -86,25 +86,39 @@ pub fn page_align_up(size: usize) -> usize { // On any real platform `1 << ps.trailing_zeros() == ps`, so this is the // same round-up it always was, for one `tzcnt` and one `shl`. let mask = (1usize << (ps.trailing_zeros() & 63)) - 1; - (size.max(1) + mask) & !mask + let base = size.max(1); + // Checked add: wrapping here is a silent shrink (OH-rusty_alloc-10). + // `usize::MAX + 4095` wraps to a small page-aligned value in release, so + // `good_size(usize::MAX)` would promise 0. Unrepresentable round-up keeps + // `base` — never shrinks, never panics. "Never 0": `size == 0` uses base 1. + match base.checked_add(mask) { + Some(s) => s & !mask, + None => base, + } } /// Reserve (and optionally commit) an aligned block of OS memory. /// /// `alignment` must be a power of two ≥ page size; `size` is rounded up to -/// pages. This is what segments (M3) and arenas (M6) sit on. +/// pages. This is what segments (M3) and arenas (M6) sit on. A non-power-of-two +/// (or zero) alignment is `Err`, not `assert!` (OH-rusty_alloc-28). pub fn alloc_aligned( size: usize, alignment: usize, commit: bool, allow_large: bool, ) -> Result { - assert!( - alignment.is_power_of_two(), - "alignment must be a power of two" - ); + // EINVAL: hostile / mistaken callers hit the `Result`, not a panic. + if !alignment.is_power_of_two() { + return Err(22); + } let alignment = alignment.max(page_size()); let size = page_align_up(size); + // Unrepresentable `size + alignment` is Err, not `size + try_alignment` + // debug overflow in the prim aligned-reserve dance (OH-rusty_alloc-29). + if size.checked_add(alignment).is_none() { + return Err(12); + } // On a platform whose `free` cannot return memory (wasm), a freed block's // only afterlife is adoption as SEGMENT_SIZE arena chunks (see [`free`]). // A segment-aligned block with a ragged size would leave a sub-chunk tail @@ -116,7 +130,8 @@ pub fn alloc_aligned( // `alignment >= SEGMENT_SIZE` is precisely the segment/huge reservation // paths; descriptor-sized allocations keep their page granularity. let size = if !prim::FREE_RETURNS_MEMORY && alignment >= crate::types::SEGMENT_SIZE { - size.next_multiple_of(crate::types::SEGMENT_SIZE) + size.checked_next_multiple_of(crate::types::SEGMENT_SIZE) + .ok_or(12u32)? } else { size }; @@ -146,6 +161,11 @@ pub fn alloc_aligned( }) } +/// Whether `[ptr, ptr+size)` is reserved or committed by the OS. +pub fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + prim::range_is_reserved(ptr, size) +} + /// Release a block from [`alloc_aligned`]. /// /// # Safety diff --git a/crates/rusty_alloc/src/page.rs b/crates/rusty_alloc/src/page.rs index fa10315..e6c5cdd 100644 --- a/crates/rusty_alloc/src/page.rs +++ b/crates/rusty_alloc/src/page.rs @@ -779,7 +779,10 @@ pub unsafe fn remote_free(page: *mut Page, block: *mut Block) { if crate::ONE_THREAD { unreachable!("a cross-thread free on a build that asserted a single thread"); } - loop { + // Both arms below detect a double free with one compare and `break` to + // the single abort AFTER the loop; see `remote_double_free` for why that + // abort is a tail call and not a diverging one. + 'push: loop { // SAFETY: xthread_free/xheap are the designed cross-thread fields. let x = unsafe { (*page).xthread_free.load(Ordering::Acquire) }; match x & XMASK { @@ -805,6 +808,12 @@ pub unsafe fn remote_free(page: *mut Page, block: *mut Block) { debug_assert!(!dl.is_null(), "DELAYED page without an owner heap"); loop { let head = (*dl).head.load(Ordering::Acquire); + // A block that is already the list head is being + // freed a second time: abort, do not link it to + // itself (OH-rusty_alloc-11). + if head == block as usize { + break 'push; + } // Delayed-list links are heap-scoped: encoding // them would need the owner's page keys here, so // they stay plain even in secure builds. @@ -846,6 +855,17 @@ pub unsafe fn remote_free(page: *mut Page, block: *mut Block) { XFLAG_FREEING => core::hint::spin_loop(), flag => { // NORMAL or NEVER: push onto the page's own list. + // + // A block that is already the chain head is being freed a + // second time. Linking it would make the chain CYCLIC + // (`block -> block`), which the owner's collect could never + // finish walking; on a NEVER page there is no owner at all, + // so the cycle sat there until a reclaim hung on it. One + // compare against a value already in a register, on the + // cross-thread path only (OH-rusty_alloc-11). + if (x & !XMASK) == block as usize { + break 'push; + } // SAFETY: block is dead memory we own; link write is the // free-list representation. unsafe { @@ -866,6 +886,28 @@ pub unsafe fn remote_free(page: *mut Page, block: *mut Block) { } } } + remote_double_free() +} + +/// A double free was detected on the cross-thread path ([`remote_free`]). +/// +/// This is deliberately NOT `-> !`, and the `black_box` is load-bearing. +/// `remote_free` is inlined into `alloc::free`, a leaf with no stack frame. +/// A callee LLVM can prove diverging is emitted as `call; ud2`, and on +/// Windows x64 that one `call` pins a frame to the TOP of `free` (SEH unwind +/// info cannot describe a prologue anywhere else, so shrink-wrapping is off) +/// — two instructions on every LOCAL free, for a check that only runs on the +/// remote arm. A callee that may return, in tail position, is a `jmp`: the +/// same shape as `alloc::retire_or_abort`, and the local path stays +/// byte-identical to the build without the check. `black_box(true)` is what +/// keeps the "may return" path visible to attribute inference; it is always +/// true, and the function never returns in practice. +#[cold] +#[inline(never)] +fn remote_double_free() { + if core::hint::black_box(true) { + double_free_abort(); + } } /// Owner/abandoner flag transition, spinning out any in-flight FREEING. @@ -995,9 +1037,28 @@ unsafe fn page_collect_impl(page: *mut Page, flag: usize) // One `block_next` per element, not two: the original loop called // it in the condition AND the body, doubling the decode (and, in // `secure`, the bound check) on every element of the walk. + // + // The CROSS-THREAD arm of the double-free check `page_push_local` + // performs, and the walk is BOUNDED by it. A block freed twice + // from another thread is linked onto `xthread_free` twice, and + // its second link points back into the chain it is already on: + // the chain is CYCLIC, so an unbounded walk here never returns — + // the post-walk `n > used` test this used to rely on was + // unreachable for the very case it named. No legitimate chain is + // longer than the number of live blocks, so `n > used` inside the + // walk turns the hang into the same abort the local path gives. + // `remote_free` refuses the consecutive case at push time; this + // catches the interleaved one (A, B, A) — OH-rusty_alloc-11. + // + // One register compare per drained element, on the heartbeat, + // not on any per-free path. + let used = (*page).used; let mut tail = head; let mut n = 1u32; loop { + if n > used { + double_free_abort(); + } #[cfg(feature = "blockmap")] blockmap_transition(page, tail.cast(), false); let nxt = block_next(page, tail); @@ -1009,18 +1070,8 @@ unsafe fn page_collect_impl(page: *mut Page, flag: usize) } block_set_next(page, tail, (*page).free); (*page).free = head; - // The CROSS-THREAD arm of the same double-free check that - // `page_push_local` performs. A block freed twice from another - // thread lands on `xthread_free` twice, so the chain length `n` - // counted here exceeds the number of live blocks and `used` wraps - // — the identical silent corruption, reached by the remote path. - // - // Free to check: `page_collect` runs on the heartbeat, not on - // every free, so this costs nothing on any hot path. - if n > (*page).used { - double_free_abort(); - } - (*page).used -= n; + // `n <= used` here: the walk aborted otherwise. + (*page).used = used - n; break; } // Reached only by breaking out of the steal arm above, i.e. a diff --git a/crates/rusty_alloc/src/prim/fixed.rs b/crates/rusty_alloc/src/prim/fixed.rs index da58ded..29deaec 100644 --- a/crates/rusty_alloc/src/prim/fixed.rs +++ b/crates/rusty_alloc/src/prim/fixed.rs @@ -399,7 +399,12 @@ pub const fn good_region_size(budget: usize) -> usize { pub const fn region_for(usable: usize) -> usize { let seg = crate::types::SEGMENT_SIZE; let segments = if usable == 0 { 1 } else { usable.div_ceil(seg) }; - segments * seg + // Unrepresentable `usable` is 0, matching [`region_for_allocs`]. A region + // of 0 is refused by [`init_region`]. + match segments.checked_mul(seg) { + Some(bytes) => bytes, + None => 0, + } } /// What one allocation of a given size costs, and which path serves it — @@ -449,9 +454,18 @@ pub const fn shape_of(size: usize) -> Shape { MEDIUM_PAGE_SIZE } else if size <= LARGE_OBJ_SIZE_MAX { // Its own span of whole slices inside a shared segment. - size.div_ceil(SEGMENT_SLICE_SIZE) * SEGMENT_SLICE_SIZE + match size + .div_ceil(SEGMENT_SLICE_SIZE) + .checked_mul(SEGMENT_SLICE_SIZE) + { + Some(n) => n, + None => 0, + } } else { - dedicated * crate::types::SEGMENT_SIZE + match dedicated.checked_mul(crate::types::SEGMENT_SIZE) { + Some(n) => n, + None => 0, + } }; Shape { page_bytes, @@ -495,7 +509,16 @@ pub const fn dedicated_segments(size: usize) -> usize { // rounded up to whole segments because the reservation must start on a // segment stride. Page-rounding inside `huge_alloc` cannot change this // count, since a segment is a whole number of pages. - (crate::types::SEGMENT_SLICE_SIZE + size).div_ceil(crate::types::SEGMENT_SIZE) + // + // Overflow is `usize::MAX`, not 0: 0 already means "shares", and a + // firmware `assert!(dedicated_segments(size) <= 1)` must fail closed on + // an unrepresentable size (OH-rusty_alloc-33). + let slice = crate::types::SEGMENT_SLICE_SIZE; + let seg = crate::types::SEGMENT_SIZE; + match slice.checked_add(size) { + Some(need) => need.div_ceil(seg), + None => usize::MAX, + } } /// The smallest region that can hold `count` simultaneously-live allocations @@ -1230,6 +1253,14 @@ pub(super) unsafe fn protect(_ptr: *mut u8, _size: usize, _on: bool) -> Result<( Err(FERR) } +pub(super) fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + let start = ptr as usize; + let Some(last) = start.checked_add(size.saturating_sub(1)) else { + return false; + }; + region_contains(start) && region_contains(last) +} + pub(super) fn numa_node_count() -> usize { 1 } diff --git a/crates/rusty_alloc/src/prim/mock.rs b/crates/rusty_alloc/src/prim/mock.rs index 0e3ba66..dce17c6 100644 --- a/crates/rusty_alloc/src/prim/mock.rs +++ b/crates/rusty_alloc/src/prim/mock.rs @@ -85,6 +85,27 @@ pub(super) unsafe fn protect(_ptr: *mut u8, _size: usize, _on: bool) -> Result<( Ok(()) } +pub(super) fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + let start = ptr as usize; + let Some(end) = start.checked_add(size) else { + return false; + }; + let Ok(reg) = registry().lock() else { + return false; + }; + let mut a = start; + while a < end { + let Some((&base, layout)) = reg.iter().find(|&(&b, l)| a >= b && a - b < l.size()) else { + return false; + }; + a = base.saturating_add(layout.size()); + if a <= start { + return false; + } + } + true +} + pub(super) fn numa_node_count() -> usize { 1 } diff --git a/crates/rusty_alloc/src/prim/mod.rs b/crates/rusty_alloc/src/prim/mod.rs index db364a9..8945d42 100644 --- a/crates/rusty_alloc/src/prim/mod.rs +++ b/crates/rusty_alloc/src/prim/mod.rs @@ -110,7 +110,13 @@ pub unsafe fn alloc( commit: bool, allow_large: bool, ) -> Result { - // SAFETY: forwarded contract. + // A non-power-of-two (or zero) alignment is Err, not `align_up`'s + // `debug_assert!` (OH-rusty_alloc-38). `os::alloc_aligned` already + // refuses; this public lower seam did not. + if !try_alignment.is_power_of_two() { + return Err(22); + } + // SAFETY: forwarded contract; alignment is a power of two. unsafe { sys::alloc(size, try_alignment, commit, allow_large) } } @@ -130,7 +136,13 @@ pub unsafe fn free(ptr: *mut u8, size: usize) -> Result<(), PrimError> { /// # Safety /// Range must lie inside a live [`alloc`] mapping, page-aligned. pub unsafe fn commit(ptr: *mut u8, size: usize) -> Result { - // SAFETY: forwarded contract. + // A null range is Err, not a fresh OS allocation (OH-rusty_alloc-60). + // Windows `VirtualAlloc(NULL, size, MEM_COMMIT)` treats a null address as + // "pick anywhere" and returns Ok with an untracked mapping. + if ptr.is_null() { + return Err(22); + } + // SAFETY: forwarded contract; base is non-null. unsafe { sys::commit(ptr, size) } } @@ -140,7 +152,10 @@ pub unsafe fn commit(ptr: *mut u8, size: usize) -> Result { /// # Safety /// Range must lie inside a live [`alloc`] mapping, page-aligned; contents lost. pub unsafe fn decommit(ptr: *mut u8, size: usize) -> Result { - // SAFETY: forwarded contract. + if ptr.is_null() { + return Err(22); + } + // SAFETY: forwarded contract; base is non-null. unsafe { sys::decommit(ptr, size) } } @@ -150,7 +165,10 @@ pub unsafe fn decommit(ptr: *mut u8, size: usize) -> Result { /// # Safety /// Range must lie inside a live, committed mapping, page-aligned. pub unsafe fn reset(ptr: *mut u8, size: usize) -> Result<(), PrimError> { - // SAFETY: forwarded contract. + if ptr.is_null() { + return Err(22); + } + // SAFETY: forwarded contract; base is non-null. unsafe { sys::reset(ptr, size) } } @@ -160,10 +178,24 @@ pub unsafe fn reset(ptr: *mut u8, size: usize) -> Result<(), PrimError> { /// Range must lie inside a live, committed mapping; caller must not touch a /// protected range until unprotected. pub unsafe fn protect(ptr: *mut u8, size: usize, protect: bool) -> Result<(), PrimError> { - // SAFETY: forwarded contract. + if ptr.is_null() { + return Err(22); + } + // SAFETY: forwarded contract; base is non-null. unsafe { sys::protect(ptr, size, protect) } } +/// Whether `[ptr, ptr+size)` is reserved or committed by the OS. +/// +/// Used by `manage_os_memory_ex` so an unmapped lie cannot become an arena +/// (OH-rusty_alloc-201). Best-effort: a racing unmap can flip the answer. +pub fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + if ptr.is_null() || size == 0 { + return false; + } + sys::range_is_reserved(ptr, size) +} + /// Number of NUMA nodes (≥ 1). M1 returns the real count on Windows, 1 on /// unix (sysfs parsing lands with arenas in M6). pub fn numa_node_count() -> usize { @@ -240,3 +272,13 @@ pub(crate) const fn align_up(n: usize, align: usize) -> usize { debug_assert!(align.is_power_of_two()); (n + align - 1) & !(align - 1) } + +/// Checked sibling of [`align_up`]. `None` when `n + align - 1` overflows +/// (OH-rusty_alloc-29). Only the Windows backend's large-page path rounds a +/// caller size up by an OS-reported unit; the others add before they align. +#[cfg(all(windows, not(miri)))] +#[inline] +pub(crate) fn align_up_checked(n: usize, align: usize) -> Option { + debug_assert!(align.is_power_of_two()); + n.checked_add(align - 1).map(|s| s & !(align - 1)) +} diff --git a/crates/rusty_alloc/src/prim/unix.rs b/crates/rusty_alloc/src/prim/unix.rs index faaacc5..5a64278 100644 --- a/crates/rusty_alloc/src/prim/unix.rs +++ b/crates/rusty_alloc/src/prim/unix.rs @@ -82,7 +82,11 @@ pub(super) unsafe fn alloc( } // Over-allocate and trim the unaligned head/tail (partial free is allowed). - let over = size + try_alignment; + // Unrepresentable `size + alignment` is Err, not a debug add overflow + // (OH-rusty_alloc-29). + let Some(over) = size.checked_add(try_alignment) else { + return Err(12); + }; // SAFETY: forwarded contract. let raw = unsafe { mmap_anon(ptr::null_mut(), over, commit)? }; let base = raw as usize; @@ -196,6 +200,32 @@ pub(super) unsafe fn protect(ptr_: *mut u8, size: usize, on: bool) -> Result<(), if r == 0 { Ok(()) } else { Err(errno()) } } +/// Whether `[ptr, ptr+size)` is mapped (`mincore` succeeds on every page). +pub(super) fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + if ptr.is_null() || size == 0 { + return false; + } + let page = mem_init().page_size.max(1); + let start = ptr as usize; + let aligned = start & !(page - 1); + let Some(span) = size.checked_add(start - aligned) else { + return false; + }; + let npages = span.div_ceil(page); + for i in 0..npages { + let p = aligned + i * page; + let mut vec = 0u8; + // SAFETY: `p` is page-aligned and `page` is one page, so the out + // vector needs one byte, which `vec` is; `mincore` reads the mapping + // table and writes only that byte. + let r = unsafe { libc::mincore(p as *mut libc::c_void, page, &mut vec) }; + if r != 0 { + return false; + } + } + true +} + pub(super) fn numa_node_count() -> usize { 1 // sysfs/getcpu wiring lands with arenas (M6) } diff --git a/crates/rusty_alloc/src/prim/wasm.rs b/crates/rusty_alloc/src/prim/wasm.rs index c4836db..7c5748b 100644 --- a/crates/rusty_alloc/src/prim/wasm.rs +++ b/crates/rusty_alloc/src/prim/wasm.rs @@ -73,7 +73,10 @@ pub(super) unsafe fn alloc( // takes one around sbrk.) let cur = memory_end(); let pad = align_up(cur, align) - cur; - let pages = (pad + size).div_ceil(WASM_PAGE); + let Some(need) = pad.checked_add(size) else { + return Err(WERR); + }; + let pages = need.div_ceil(WASM_PAGE); let prev = core::arch::wasm32::memory_grow::<0>(pages); if prev == usize::MAX { @@ -147,6 +150,15 @@ pub(super) unsafe fn protect(_ptr: *mut u8, _size: usize, _on: bool) -> Result<( Err(WERR) } +pub(super) fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + let start = ptr as usize; + let Some(end) = start.checked_add(size) else { + return false; + }; + let lim = memory_end(); + start < lim && end <= lim +} + pub(super) fn numa_node_count() -> usize { 1 } diff --git a/crates/rusty_alloc/src/prim/windows.rs b/crates/rusty_alloc/src/prim/windows.rs index 93e5e11..8a80683 100644 --- a/crates/rusty_alloc/src/prim/windows.rs +++ b/crates/rusty_alloc/src/prim/windows.rs @@ -14,8 +14,9 @@ use core::sync::atomic::{AtomicU64, Ordering}; use windows_sys::Win32::Foundation::GetLastError; use windows_sys::Win32::System::Memory::{ - GetLargePageMinimum, MEM_COMMIT, MEM_DECOMMIT, MEM_LARGE_PAGES, MEM_RELEASE, MEM_RESERVE, - MEM_RESET, PAGE_NOACCESS, PAGE_READWRITE, VirtualAlloc, VirtualFree, VirtualProtect, + GetLargePageMinimum, MEM_COMMIT, MEM_DECOMMIT, MEM_FREE, MEM_LARGE_PAGES, MEM_RELEASE, + MEM_RESERVE, MEM_RESET, MEMORY_BASIC_INFORMATION, PAGE_NOACCESS, PAGE_READWRITE, VirtualAlloc, + VirtualFree, VirtualProtect, VirtualQuery, }; use windows_sys::Win32::System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency}; use windows_sys::Win32::System::SystemInformation::{GetSystemInfo, SYSTEM_INFO}; @@ -62,27 +63,30 @@ pub(super) unsafe fn alloc( // SAFETY: no preconditions. let large_min = unsafe { GetLargePageMinimum() }; if large_min > 0 && try_alignment <= large_min && size >= large_min { - let lsize = align_up(size, large_min); - // SAFETY: NULL base + valid flags; failure returns null, handled. - let p = unsafe { - VirtualAlloc(ptr::null(), lsize, flags | MEM_LARGE_PAGES, PAGE_READWRITE) - }; - // `is_multiple_of` on a RUNTIME divisor is a modulo, i.e. a real - // `div`. Same substitution as D7/D12/D19; this site was missed - // because it is Windows-only and every scan in that campaign read - // the Linux `.so`. `is_aligned_to`'s conservative direction is the - // safe one here: a `false` falls through to the aligned-reservation - // retry below rather than accepting a block. - if !p.is_null() && crate::bins::is_aligned_to(p as usize, try_alignment) { - return Ok(Alloc { - ptr: p.cast(), - is_large: true, - is_zero: true, - }); - } - if !p.is_null() { - // SAFETY: p is a whole mapping we just made and never exposed. - unsafe { VirtualFree(p, 0, MEM_RELEASE) }; + // Unrepresentable large-page round-up falls through to normal pages + // (OH-rusty_alloc-29). + if let Some(lsize) = super::align_up_checked(size, large_min) { + // SAFETY: NULL base + valid flags; failure returns null, handled. + let p = unsafe { + VirtualAlloc(ptr::null(), lsize, flags | MEM_LARGE_PAGES, PAGE_READWRITE) + }; + // `is_multiple_of` on a RUNTIME divisor is a modulo, i.e. a real + // `div`. Same substitution as D7/D12/D19; this site was missed + // because it is Windows-only and every scan in that campaign read + // the Linux `.so`. `is_aligned_to`'s conservative direction is the + // safe one here: a `false` falls through to the aligned-reservation + // retry below rather than accepting a block. + if !p.is_null() && crate::bins::is_aligned_to(p as usize, try_alignment) { + return Ok(Alloc { + ptr: p.cast(), + is_large: true, + is_zero: true, + }); + } + if !p.is_null() { + // SAFETY: p is a whole mapping we just made and never exposed. + unsafe { VirtualFree(p, 0, MEM_RELEASE) }; + } } // fall through to normal pages } @@ -107,15 +111,11 @@ pub(super) unsafe fn alloc( // re-reserve exactly there. Another thread can steal the range between the // two calls, hence the retry loop (upstream uses 3 tries as well). for _ in 0..3 { - // SAFETY: reserve-only of an oversized range; failure handled. - let probe = unsafe { - VirtualAlloc( - ptr::null(), - size + try_alignment, - MEM_RESERVE, - PAGE_NOACCESS, - ) + let Some(over) = size.checked_add(try_alignment) else { + return Err(12); // ENOMEM: unrepresentable aligned-reserve (OH-rusty_alloc-29) }; + // SAFETY: reserve-only of an oversized range; failure handled. + let probe = unsafe { VirtualAlloc(ptr::null(), over, MEM_RESERVE, PAGE_NOACCESS) }; if probe.is_null() { return Err(last_error()); } @@ -153,6 +153,15 @@ pub(super) unsafe fn commit(ptr_: *mut u8, size: usize) -> Result Result<(), if ok != 0 { Ok(()) } else { Err(last_error()) } } +/// Whether `[ptr, ptr+size)` is reserved or committed (not `MEM_FREE`). +pub(super) fn range_is_reserved(ptr: *const u8, size: usize) -> bool { + if ptr.is_null() || size == 0 { + return false; + } + let mut addr = ptr as usize; + let Some(end) = addr.checked_add(size) else { + return false; + }; + while addr < end { + // SAFETY: `MEMORY_BASIC_INFORMATION` is plain data (pointers and + // integers); all-zero is a valid value of it. + let mut mbi = unsafe { core::mem::zeroed::() }; + // SAFETY: read-only query; the out-pointer is a live local of exactly + // the length passed. + let n = unsafe { + VirtualQuery( + addr as *const c_void, + &mut mbi, + core::mem::size_of::(), + ) + }; + if n == 0 || mbi.State == MEM_FREE || mbi.RegionSize == 0 { + return false; + } + let region_end = (mbi.BaseAddress as usize).saturating_add(mbi.RegionSize); + if region_end <= addr { + return false; + } + addr = region_end; + } + true +} + pub(super) fn numa_node_count() -> usize { let mut highest = 0u32; // SAFETY: out-param is a valid local. diff --git a/crates/rusty_alloc/src/segment.rs b/crates/rusty_alloc/src/segment.rs index e93d2f6..e13518d 100644 --- a/crates/rusty_alloc/src/segment.rs +++ b/crates/rusty_alloc/src/segment.rs @@ -810,7 +810,12 @@ pub fn huge_alloc( offset: usize, arena_id: i32, ) -> Result<(*mut Segment, *mut u8), PrimError> { - debug_assert!(align.is_power_of_two() && align <= SEGMENT_SIZE / 2); + // A garbage alignment is EINVAL, not a `debug_assert!`: this is a safe + // `pub fn`, and the mask arithmetic below is only sound for a power of + // two. Cold path (dedicated segment), so the two compares are free. + if !align.is_power_of_two() || align > SEGMENT_SIZE / 2 { + return Err(22); + } let header = SEGMENT_SLICE_SIZE; // Worst-case room for placing the block within the reservation. Hosted, // the area is slice-aligned, so only larger alignments — or offsets that @@ -832,7 +837,15 @@ pub fn huge_alloc( } else { 0 }; - let want = os::page_align_up(header + size + extra); + // An unsatisfiable reservation (`malloc(usize::MAX)`) is an error, not a + // `header + size` debug overflow or a wrapped small reservation. + let Some(raw) = header.checked_add(size).and_then(|s| s.checked_add(extra)) else { + return Err(0); + }; + let want = os::page_align_up(raw); + if want < raw { + return Err(0); + } // Huge blocks recycle through arenas too (contiguous chunks) — without // this, every huge alloc/free cycle is an OS round-trip (the Tier-A // malloc-large gate measured 3–4× slower before this path). @@ -845,8 +858,11 @@ pub fn huge_alloc( // (`mi_segment_huge_page_alloc`, oracle segment.c:1671/1683); we did not. // See `tests/heaps.rs::exclusive_arena_confines_huge_allocations`. let chunks = want.div_ceil(SEGMENT_SIZE); + let Some(chunk_bytes) = chunks.checked_mul(SEGMENT_SIZE) else { + return Err(0); + }; let (bptr, total, mem_zero) = match crate::arena::chunk_alloc_n(arena_id, chunks) { - Some((p, zero)) => (p, chunks * SEGMENT_SIZE, zero), + Some((p, zero)) => (p, chunk_bytes, zero), None => { if arena_id >= 0 { return Err(0); // exclusive-arena heap and its arena is full @@ -883,7 +899,19 @@ pub fn huge_alloc( (*seg).free_spans = ptr::null_mut(); let area = b.ptr.add(header); // (block + offset) aligned: round (area + offset) up, subtract offset. - let block = area.with_addr(((area.addr() + offset + align - 1) & !(align - 1)) - offset); + // `area + offset + align` can wrap for a caller-chosen offset; that is + // an unsatisfiable request, not a block placed by wrapped arithmetic. + let Some(addr) = crate::bins::aligned_at_from(area.addr(), offset, align) else { + // SAFETY: the reservation is registered and unused; no block escaped. + let _ = huge_free(seg); + return Err(0); + }; + if addr < area.addr() { + // SAFETY: as the overflow arm. + let _ = huge_free(seg); + return Err(0); + } + let block = area.with_addr(addr); debug_assert!(block.addr() >= area.addr() && (block.addr() + offset).is_multiple_of(align)); // The single page lives in slot 1; every reachable interior slice // offsets back to it (only slices 1..512 are addressable via the mask diff --git a/crates/rusty_alloc/src/segment_map.rs b/crates/rusty_alloc/src/segment_map.rs index 1a02b13..f1f8f2f 100644 --- a/crates/rusty_alloc/src/segment_map.rs +++ b/crates/rusty_alloc/src/segment_map.rs @@ -133,7 +133,13 @@ mod range_table { for i in 0..MAX_RANGES { if END[i].load(Ordering::Relaxed) == 0 { BASE[i].store(base, Ordering::Relaxed); - END[i].store(base + size.max(1), Ordering::Release); + // A range that wraps the address space cannot be recorded; + // latch the same fail-closed flag a full table does. + let Some(end) = base.checked_add(size.max(1)) else { + OVERFLOWED.store(true, Ordering::Release); + return; + }; + END[i].store(end, Ordering::Release); return; } } @@ -155,7 +161,7 @@ mod range_table { /// Forget `[base, base+size)`. Matches on the base, so an unregister that /// was never registered is a no-op. pub(super) fn clear(base: usize, size: usize) { - let end = base + size.max(1); + let end = base.saturating_add(size.max(1)); let _g = Guard::acquire(); for i in 0..MAX_RANGES { if BASE[i].load(Ordering::Relaxed) == base && END[i].load(Ordering::Relaxed) == end { @@ -204,7 +210,10 @@ mod base_table { fn slots(base: usize, size: usize) -> core::ops::Range { let start = base >> SLICE_SHIFT; - let end = (base + size.max(1)).div_ceil(1 << SLICE_SHIFT).min(SLOTS); + let end = base + .saturating_add(size.max(1)) + .div_ceil(1 << SLICE_SHIFT) + .min(SLOTS); start.min(SLOTS)..end } @@ -257,6 +266,28 @@ pub fn register(seg: *mut Segment) { register_range(seg.addr(), SEGMENT_SIZE); } +/// Walk every representable window of `[base, base+size)`. Stops at the +/// first address the bitmap cannot name (above `ADDR_BITS`) and on +/// `checked_add` overflow: a range ending within one window of the top of +/// the address space used to wrap `a` back to 0 and walk the whole map +/// (OH-rusty_alloc-30). Reachable from a caller-supplied `manage_os_memory` +/// range, so bounded here as well as there. +#[cfg(all(not(ra_small_profile), not(all(target_arch = "wasm32", not(miri)))))] +fn walk_windows(base: usize, size: usize, mut op: impl FnMut(usize, u32)) { + let mut a = base; + let end = base.saturating_add(size.max(1)); + while a < end { + match locate(a) { + Some((w, bit)) => op(w, bit), + None => break, + } + match a.checked_add(SEGMENT_SIZE) { + Some(n) => a = n, + None => break, + } + } +} + /// Register every 32 MiB window overlapped by `[base, base+size)` /// (on wasm: every 64 KiB slice, in the base table). pub fn register_range(base: usize, size: usize) { @@ -277,14 +308,9 @@ pub fn register_range(base: usize, size: usize) { } #[cfg(all(not(ra_small_profile), not(all(target_arch = "wasm32", not(miri)))))] { - let mut a = base; - let end = base + size.max(1); - while a < end { - if let Some((w, bit)) = locate(a) { - MAP[w].fetch_or(bit, Ordering::Release); - } - a += SEGMENT_SIZE; - } + walk_windows(base, size, |w, bit| { + MAP[w].fetch_or(bit, Ordering::Release); + }); } } @@ -308,14 +334,9 @@ pub fn unregister_range(base: usize, size: usize) { } #[cfg(all(not(ra_small_profile), not(all(target_arch = "wasm32", not(miri)))))] { - let mut a = base; - let end = base + size.max(1); - while a < end { - if let Some((w, bit)) = locate(a) { - MAP[w].fetch_and(!bit, Ordering::Release); - } - a += SEGMENT_SIZE; - } + walk_windows(base, size, |w, bit| { + MAP[w].fetch_and(!bit, Ordering::Release); + }); } } diff --git a/crates/rusty_alloc/tests/double_free.rs b/crates/rusty_alloc/tests/double_free.rs index 2b6fe00..a64591b 100644 --- a/crates/rusty_alloc/tests/double_free.rs +++ b/crates/rusty_alloc/tests/double_free.rs @@ -58,3 +58,141 @@ fn double_free_aborts_instead_of_corrupting() { "the second free RETURNED: detection did not fire" ); } + +const ABANDON_MARKER: &str = "RUSTY_ALLOC_ABANDON_DOUBLE_FREE_CHILD"; + +/// A block abandoned by a dying thread, then freed twice from another thread. +/// NEVER-page `remote_free` used to push the same block onto `xthread_free` +/// twice and return (OH-rusty_alloc-11). +#[cfg_attr(miri, ignore)] +#[test] +fn abandoned_double_free_aborts() { + if std::env::var(ABANDON_MARKER).is_ok() { + let addr = std::thread::spawn(|| { + let p = rusty_alloc::alloc::malloc(192); + assert!(!p.is_null()); + p.expose_provenance() + }) + .join() + .expect("allocator thread"); + let p = core::ptr::with_exposed_provenance_mut::(addr); + // SAFETY: `p` is live; the SECOND call is the bug under test, and the + // allocator must abort there rather than return. + unsafe { + rusty_alloc::alloc::free(p); + rusty_alloc::alloc::free(p); + } + eprintln!("child: second free of abandoned block RETURNED"); + std::process::exit(97); + } + + let exe = std::env::current_exe().expect("current_exe"); + let out = Command::new(exe) + .env(ABANDON_MARKER, "1") + .args(["--exact", "abandoned_double_free_aborts"]) + .output() + .expect("spawn child"); + assert!( + !out.status.success(), + "abandoned double free was accepted silently" + ); + assert_ne!( + out.status.code(), + Some(97), + "the second free of an abandoned block RETURNED" + ); +} + +const SET_DEFAULT_ABANDON_MARKER: &str = "RUSTY_ALLOC_SET_DEFAULT_ABANDON_DF_CHILD"; +const FIRST_CLASS_ABANDON_MARKER: &str = "RUSTY_ALLOC_FIRST_CLASS_ABANDON_DF_CHILD"; + +/// `set_default_heap` then thread exit: the installed heap must be abandoned +/// (NEVER), so a second remote free aborts (OH-rusty_alloc-13). +#[cfg_attr(miri, ignore)] +#[test] +fn set_default_heap_abandoned_double_free_aborts() { + if std::env::var(SET_DEFAULT_ABANDON_MARKER).is_ok() { + let addr = std::thread::spawn(|| { + let h = rusty_alloc::init::create_heap(0, false, -1); + assert!(!h.is_null()); + // SAFETY: `h` is a live heap this thread just created and owns. + unsafe { + let _prev = rusty_alloc::init::set_default_heap(h); + let p = rusty_alloc::alloc::malloc(80); + assert!(!p.is_null()); + p.expose_provenance() + } + }) + .join() + .expect("set_default thread"); + let p = core::ptr::with_exposed_provenance_mut::(addr); + // SAFETY: `p` is live; the SECOND call is the bug under test, and the + // allocator must abort there rather than return. + unsafe { + rusty_alloc::alloc::free(p); + rusty_alloc::alloc::free(p); + } + eprintln!("child: second free after set_default_heap+exit RETURNED"); + std::process::exit(97); + } + + let exe = std::env::current_exe().expect("current_exe"); + let out = Command::new(exe) + .env(SET_DEFAULT_ABANDON_MARKER, "1") + .args(["--exact", "set_default_heap_abandoned_double_free_aborts"]) + .output() + .expect("spawn child"); + assert!( + !out.status.success(), + "set_default abandoned double free was accepted silently" + ); + assert_ne!( + out.status.code(), + Some(97), + "the second free after set_default_heap+exit RETURNED" + ); +} + +/// First-class heap leaked at thread exit (never `heap_delete`): second remote +/// free must abort (OH-rusty_alloc-13 sibling of the default-heap path). +#[cfg_attr(miri, ignore)] +#[test] +fn first_class_heap_abandoned_double_free_aborts() { + if std::env::var(FIRST_CLASS_ABANDON_MARKER).is_ok() { + let addr = std::thread::spawn(|| { + let h = rusty_alloc::init::create_heap(0, false, -1); + assert!(!h.is_null()); + // SAFETY: `h` is a live heap this thread just created and owns. + let p = unsafe { rusty_alloc::alloc::heap_malloc(h, 64) }; + assert!(!p.is_null()); + p.expose_provenance() + }) + .join() + .expect("first-class heap thread"); + let p = core::ptr::with_exposed_provenance_mut::(addr); + // SAFETY: `p` is live; the SECOND call is the bug under test, and the + // allocator must abort there rather than return. + unsafe { + rusty_alloc::alloc::free(p); + rusty_alloc::alloc::free(p); + } + eprintln!("child: second free of first-class abandoned block RETURNED"); + std::process::exit(97); + } + + let exe = std::env::current_exe().expect("current_exe"); + let out = Command::new(exe) + .env(FIRST_CLASS_ABANDON_MARKER, "1") + .args(["--exact", "first_class_heap_abandoned_double_free_aborts"]) + .output() + .expect("spawn child"); + assert!( + !out.status.success(), + "first-class abandoned double free was accepted silently" + ); + assert_ne!( + out.status.code(), + Some(97), + "the second free of a first-class abandoned block RETURNED" + ); +} diff --git a/crates/rusty_alloc/tests/openheimer.rs b/crates/rusty_alloc/tests/openheimer.rs new file mode 100644 index 0000000..1bf8d3c --- /dev/null +++ b/crates/rusty_alloc/tests/openheimer.rs @@ -0,0 +1,592 @@ +//! Openheimer standing pack for `rusty_alloc` (campaign F-IDs). +//! +//! These are fail-closed assertions on the public allocation surface. They +//! exist so the campaign has one named file; several already lived in +//! `alloc_core.rs` / `double_free.rs` / `corruption.rs`. A duplicate here is +//! deliberate: if someone deletes the original, this pack still fails. +//! +//! Source of truth: `f:/coding/openheimer/docs/plans/openheimer.md` §5.6. +//! Campaign-only hostile cases (stale realloc, legal interior free, …) live +//! in the openheimer repo: `probes/rusty_alloc/tests/hostile.rs`. + +use rusty_alloc::alloc::{ + calloc, calloc_aligned, free, malloc, malloc_aligned, malloc_aligned_at, mallocn, recalloc, +}; +use rusty_alloc::bins::{self, is_aligned_to}; +use rusty_alloc::init; + +/// F-04: count×size overflow is null, never a wrapped small allocation. +#[test] +fn oh_f04_calloc_overflow_returns_null() { + assert!(calloc(usize::MAX / 2, 3).is_null()); + assert!(mallocn(usize::MAX, 2).is_null()); + // SAFETY: null input is a documented no-op/overflow-null path (same as alloc_core). + assert!(unsafe { recalloc(core::ptr::null_mut(), usize::MAX / 2, 3) }.is_null()); +} + +/// F-04: a non-power-of-two alignment is refused, not silently masked. +#[test] +fn oh_f04_non_power_of_two_align_returns_null() { + assert!(malloc_aligned(64, 3).is_null()); + assert!(malloc_aligned(64, 0).is_null()); + assert!(malloc_aligned(64, 12).is_null()); +} + +/// F-01 / F-03: a size that does not wrap `count×size` but cannot be a +/// reservation (`malloc(usize::MAX)`) is null, not `header + size` overflow +/// in `huge_alloc` (OH-rusty_alloc-9). +#[test] +fn oh_f01_huge_nonwrapping_size_returns_null() { + let r = std::panic::catch_unwind(|| malloc(usize::MAX)); + assert!(r.is_ok(), "malloc(usize::MAX) panicked in huge_alloc"); + assert!(r.unwrap().is_null()); + let c = std::panic::catch_unwind(|| calloc(usize::MAX, 1)); + assert!(c.is_ok(), "calloc(usize::MAX, 1) panicked in huge_alloc"); + assert!(c.unwrap().is_null()); +} + +/// F-01 / F-04: `good_size(usize::MAX)` must not panic (debug `page_align_up` +/// add) and must not wrap to 0 in release (OH-rusty_alloc-10). +#[test] +fn oh_f04_good_size_huge_does_not_shrink() { + let r = std::panic::catch_unwind(|| rusty_alloc::bins::good_size(usize::MAX)); + assert!(r.is_ok(), "good_size(usize::MAX) panicked in page_align_up"); + let g = r.unwrap(); + assert_eq!(g, usize::MAX, "good_size(usize::MAX) shrank"); +} + +/// F-01: align 0 on a *warm* heap (free list non-empty) is still null, not a +/// debug `align - 1` overflow. A cold-heap probe short-circuits on a null +/// free-list head and never evaluates the mask (OH-rusty_alloc-8). +#[test] +fn oh_f01_align_zero_on_warm_heap_returns_null() { + let p = malloc(64); + assert!(!p.is_null()); + // SAFETY: `p` is live and ours; freed once, to warm the free list. + unsafe { free(p) }; + let r = std::panic::catch_unwind(|| malloc_aligned(64, 0)); + assert!(r.is_ok(), "malloc_aligned(64, 0) panicked on a warm heap"); + assert!(r.unwrap().is_null()); + let c = std::panic::catch_unwind(|| calloc_aligned(4, 16, 0)); + assert!(c.is_ok(), "calloc_aligned(..., 0) panicked on a warm heap"); + assert!(c.unwrap().is_null()); +} + +/// F-01 / F-04: a huge aligned-at offset is null, not a debug overflow panic +/// and not a wrapped interior pointer (OH-rusty_alloc-6). +#[test] +fn oh_f04_aligned_at_huge_offset_returns_null() { + assert!(malloc_aligned_at(16, 8, usize::MAX).is_null()); +} + +/// F-04: `is_aligned_to` is total — a non-power-of-two align is `false`, +/// never a `div` on a runtime divisor and never "aligned to 3". +#[test] +fn oh_f04_is_aligned_to_is_total() { + assert!( + !is_aligned_to(4, 3), + "4 is not aligned to 3; a mask would lie" + ); + assert!(!is_aligned_to(6, 3)); + assert!(!is_aligned_to(8, 0)); + assert!(is_aligned_to(8, 8)); + assert!(is_aligned_to(16, 8)); + assert!(!is_aligned_to(17, 8)); +} + +/// F-04: arena reserve of an unsatisfiable size is Err, not +/// `chunks * SEGMENT_SIZE` overflow (OH-rusty_alloc-12). +#[test] +fn oh_f04_arena_reserve_huge_is_err() { + let r = std::panic::catch_unwind(|| { + rusty_alloc::arena::reserve_os_memory_ex(usize::MAX, true, false, true) + }); + assert!(r.is_ok(), "reserve_os_memory_ex(usize::MAX) panicked"); + assert!(r.unwrap().is_err(), "huge arena reserve succeeded"); +} + +/// F-04: adopting a null / overflowing OS range is Err, not a fake arena +/// covering the address space (OH-rusty_alloc-15). +#[test] +fn oh_f04_manage_os_memory_null_is_err() { + assert!( + rusty_alloc::arena::manage_os_memory_ex( + core::ptr::null_mut(), + usize::MAX, + true, + false, + false, + -1, + false, + ) + .is_err() + ); + assert!( + rusty_alloc::arena::manage_os_memory_ex( + core::ptr::with_exposed_provenance_mut(usize::MAX - 8), + 64, + true, + false, + false, + -1, + false, + ) + .is_err() + ); +} + +/// F-03: malloc(0) is a unique freeable pointer, not null (C contract this +/// crate documents). Complements overflow-null: zero is valid, wrap is not. +#[test] +fn oh_f03_malloc_zero_is_freeable_and_unique() { + let a = malloc(0); + let b = malloc(0); + assert!(!a.is_null() && !b.is_null()); + assert_ne!(a, b); + // SAFETY: both live, freed once. + unsafe { + rusty_alloc::alloc::free(a); + rusty_alloc::alloc::free(b); + } +} + +/// F-01: inverted `get_clamp` bounds are swapped, not `i64::clamp`'s assert +/// (OH-rusty_alloc-18). +#[test] +fn oh_f01_option_get_clamp_inverted_is_total() { + let r = std::panic::catch_unwind(|| rusty_alloc::options::get_clamp(0, 10, 1)); + assert!(r.is_ok(), "get_clamp(min>max) panicked"); + let c = r.unwrap(); + assert!((1..=10).contains(&c), "inverted clamp produced {c}"); +} + +/// F-04: KiB-scaled `get_size` must not wrap `v * 1024` (OH-rusty_alloc-19). +#[test] +fn oh_f04_option_get_size_huge_does_not_wrap() { + let old = rusty_alloc::options::get(23); + rusty_alloc::options::set(23, i64::MAX); + let r = std::panic::catch_unwind(|| rusty_alloc::options::get_size(23)); + rusty_alloc::options::set(23, old); + assert!(r.is_ok(), "get_size(MAX KiB) panicked"); + assert!(r.unwrap() >= 1024, "get_size wrapped to a small byte count"); +} + +/// F-01: `perc = usize::MAX` is a bool, not `capacity * perc` overflow +/// (OH-rusty_alloc-20). +#[test] +fn oh_f01_page_under_utilized_huge_perc_is_bool() { + let p = malloc(64); + assert!(!p.is_null()); + // SAFETY: `hb` is this thread's live heap box and `p` its live block. + let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| unsafe { + let hb = rusty_alloc::init::heap_box(); + (*(*hb).heap.get()).page_under_utilized(p, usize::MAX) + })); + // SAFETY: `p` is live and ours; freed once. + unsafe { free(p) }; + assert!(r.is_ok(), "page_under_utilized(MAX perc) panicked"); +} + +/// F-01: a lying subprocess id is a no-op, not an assert (OH-rusty_alloc-21). +#[test] +fn oh_f01_subproc_add_oob_is_noop() { + let r = std::panic::catch_unwind(|| rusty_alloc::init::subproc_add_current_thread(usize::MAX)); + assert!(r.is_ok(), "subproc_add_current_thread(MAX) panicked"); +} + +/// F-04: `chunk_alloc_n(..., 0)` is None, not a pointer with no bits claimed +/// (OH-rusty_alloc-22). +#[test] +fn oh_f04_chunk_alloc_n_zero_is_none() { + let bytes = rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2); + let Ok(id) = rusty_alloc::arena::reserve_os_memory_ex(bytes, true, false, true) else { + return; + }; + assert!(rusty_alloc::arena::chunk_alloc_n(id, 1).is_some()); + assert!(rusty_alloc::arena::chunk_alloc_n(id, 0).is_none()); +} + +/// F-01: a deferred-free hook that allocates must not recurse until the stack +/// dies (OH-rusty_alloc-17). +#[test] +fn oh_f01_deferred_free_hook_that_mallocs_is_contained() { + unsafe extern "C" fn hook(_force: bool, _hb: u64, _arg: *mut core::ffi::c_void) { + let q = malloc(32); + if !q.is_null() { + // SAFETY: `q` was just allocated here; freed once. + unsafe { free(q) }; + } + } + rusty_alloc::options::register_deferred_free(Some(hook), core::ptr::null_mut()); + let r = std::panic::catch_unwind(|| malloc(2 * 1024 * 1024)); + rusty_alloc::options::register_deferred_free(None, core::ptr::null_mut()); + assert!(r.is_ok(), "malloc with deferred-free hook panicked"); + if let Ok(p) = r + && !p.is_null() + { + // SAFETY: `p` is the block `malloc` returned above; freed once. + unsafe { free(p) }; + } +} + +/// F-01: an error hook that calls `error` again must not overflow the stack +/// (OH-rusty_alloc-23). +#[test] +fn oh_f01_error_hook_reentry_is_contained() { + unsafe extern "C" fn hook(err: i32, _arg: *mut core::ffi::c_void) { + rusty_alloc::options::error(err); + } + rusty_alloc::options::register_error(Some(hook), core::ptr::null_mut()); + rusty_alloc::options::error(12); + rusty_alloc::options::register_error(None, core::ptr::null_mut()); +} + +/// F-01: an output hook that calls `out_fmt` again must not overflow the stack +/// (OH-rusty_alloc-24). +#[test] +fn oh_f01_output_hook_reentry_is_contained() { + unsafe extern "C" fn hook(_msg: *const i8, _arg: *mut core::ffi::c_void) { + rusty_alloc::options::out_fmt("nested"); + } + rusty_alloc::options::register_output(Some(hook), core::ptr::null_mut()); + rusty_alloc::options::out_fmt("hi"); + rusty_alloc::options::register_output(None, core::ptr::null_mut()); +} + +/// F-04 / F-05: `chunk_free_n` of 0 or `usize::MAX` is false, not a bitmap OOB +/// (OH-rusty_alloc-25). +#[test] +fn oh_f04_chunk_free_n_zero_and_huge_are_false() { + let bytes = rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2); + let Ok(id) = rusty_alloc::arena::reserve_os_memory_ex(bytes, true, false, true) else { + return; + }; + let Some((p, _)) = rusty_alloc::arena::chunk_alloc_n(id, 1) else { + return; + }; + assert!(!rusty_alloc::arena::chunk_free_n(p, 0)); + let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + rusty_alloc::arena::chunk_free_n(p, usize::MAX) + })); + assert!(r.is_ok(), "chunk_free_n(MAX) panicked"); + assert!(!r.unwrap()); + assert!(rusty_alloc::arena::chunk_free(p)); +} + +/// F-05: an interior pointer into a live chunk is not a successful free +/// (OH-rusty_alloc-27). The chunk start must still be reclaimable afterwards. +#[test] +fn oh_f05_chunk_free_interior_is_false() { + let bytes = rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2); + let Ok(id) = rusty_alloc::arena::reserve_os_memory_ex(bytes, true, false, true) else { + return; + }; + let Some((p, _)) = rusty_alloc::arena::chunk_alloc_n(id, 1) else { + return; + }; + let interior = p.wrapping_add(4096); + assert!(!rusty_alloc::arena::chunk_free(interior)); + assert!(!rusty_alloc::arena::chunk_free_n(interior, 1)); + assert!(rusty_alloc::arena::chunk_free(p)); +} + +/// F-01: `os::alloc_aligned` with a non-power-of-two align is `Err`, not +/// `assert!` (OH-rusty_alloc-28). +#[test] +fn oh_f01_os_alloc_aligned_bad_align_is_err() { + for align in [0usize, 3, 12] { + let r = + std::panic::catch_unwind(|| rusty_alloc::os::alloc_aligned(4096, align, true, false)); + assert!(r.is_ok(), "os::alloc_aligned(align={align}) panicked"); + assert!( + r.unwrap().is_err(), + "os::alloc_aligned(align={align}) succeeded" + ); + } +} + +/// F-01 / F-04: `os::alloc_aligned(usize::MAX, page)` is Err, not +/// `size + alignment` overflow in the prim aligned-reserve dance +/// (OH-rusty_alloc-29). +#[test] +fn oh_f01_os_alloc_aligned_max_is_err() { + let ps = rusty_alloc::os::page_size(); + let r = + std::panic::catch_unwind(|| rusty_alloc::os::alloc_aligned(usize::MAX, ps, true, false)); + assert!(r.is_ok(), "os::alloc_aligned(MAX, page) panicked"); + assert!( + r.unwrap().is_err(), + "os::alloc_aligned(MAX, page) succeeded" + ); + let r = std::panic::catch_unwind(|| { + rusty_alloc::os::alloc_aligned(usize::MAX, rusty_alloc::types::SEGMENT_SIZE, true, false) + }); + assert!(r.is_ok(), "os::alloc_aligned(MAX, SEGMENT) panicked"); + assert!( + r.unwrap().is_err(), + "os::alloc_aligned(MAX, SEGMENT) succeeded" + ); +} + +/// F-05: `arena_area` past the 32-slot table is null, not `ARENAS[id]` OOB. +#[test] +fn oh_f05_arena_area_past_max_is_null() { + let (p, sz) = rusty_alloc::arena::arena_area(32); + assert!(p.is_null()); + assert_eq!(sz, 0); + let (p, sz) = rusty_alloc::arena::arena_area(i32::MAX); + assert!(p.is_null()); + assert_eq!(sz, 0); + let (p, sz) = rusty_alloc::arena::arena_area(-1); + assert!(p.is_null()); + assert_eq!(sz, 0); +} + +/// F-01 / F-04: with guarded sampling on, `malloc(MAX)` is null, not +/// `payload + page` overflow (OH-rusty_alloc-31). Restores rate 0 so later +/// tests in this binary are not all guarded. +#[test] +fn oh_f01_guarded_malloc_max_is_null() { + let hb = init::heap_box(); + // SAFETY: `hb` is this thread's live heap box; the setters take the owner. + unsafe { + (*(*hb).heap.get()).guarded_set_size_bound(0, usize::MAX); + (*(*hb).heap.get()).guarded_set_sample_rate(1, 1); + } + let r = std::panic::catch_unwind(|| malloc(usize::MAX)); + // SAFETY: as above. + unsafe { + (*(*hb).heap.get()).guarded_set_sample_rate(0, 0); + } + assert!(r.is_ok(), "guarded malloc(MAX) panicked"); + assert!( + r.unwrap().is_null(), + "guarded malloc(MAX) wrapped to a pointer" + ); +} + +/// F-01 / F-04: public `bin_size` of a garbage index is 0, not `bin + 3` +/// overflow (OH-rusty_alloc-32). +#[test] +fn oh_f04_bin_size_garbage_index_is_total() { + let r = std::panic::catch_unwind(|| bins::bin_size(usize::MAX)); + assert!(r.is_ok(), "bin_size(MAX) panicked"); + assert_eq!(r.unwrap(), 0); + assert_eq!(bins::bin_size(0), 0); +} + +/// F-01 / F-04: `dedicated_segments(MAX)` is unrepresentable (`usize::MAX`), +/// not `SLICE + size` overflow, and not 0 (which already means "shares") +/// (OH-rusty_alloc-33). +#[test] +fn oh_f04_dedicated_segments_max_is_unrepresentable() { + use rusty_alloc::prim::fixed::{dedicated_segments, shape_of}; + let r = std::panic::catch_unwind(|| dedicated_segments(usize::MAX)); + assert!(r.is_ok(), "dedicated_segments(MAX) panicked"); + let n = r.unwrap(); + assert_ne!(n, 0, "dedicated_segments(MAX) = 0 would lie as 'shares'"); + assert_eq!(n, usize::MAX); + assert_eq!(dedicated_segments(0), 0); + assert_eq!( + dedicated_segments(rusty_alloc::types::LARGE_OBJ_SIZE_MAX), + 0 + ); + let r = std::panic::catch_unwind(|| shape_of(usize::MAX)); + assert!(r.is_ok(), "shape_of(MAX) panicked"); + assert_eq!(r.unwrap().dedicated_segments, n); +} + +/// F-01 / F-04: `region_for(MAX)` is 0, not `segments * SEGMENT_SIZE` +/// overflow (OH-rusty_alloc-34). +#[test] +fn oh_f04_region_for_max_is_zero() { + use rusty_alloc::prim::fixed::{region_for, region_for_allocs}; + let r = std::panic::catch_unwind(|| region_for(usize::MAX)); + assert!(r.is_ok(), "region_for(MAX) panicked"); + assert_eq!(r.unwrap(), 0); + assert_eq!(region_for(0), rusty_alloc::types::SEGMENT_SIZE); + let r = std::panic::catch_unwind(|| region_for_allocs(usize::MAX, 1)); + assert!(r.is_ok(), "region_for_allocs(MAX, 1) panicked"); + assert_eq!(r.unwrap(), 0); +} + +/// F-01: `prim::alloc` garbage align is Err, not `align_up` debug_assert +/// (OH-rusty_alloc-38). +#[test] +fn oh_f01_prim_alloc_bad_align_is_err() { + // SAFETY: the OS wrapper is handed a garbage alignment; the assertion is + // that it refuses BEFORE any syscall, so nothing is mapped or leaked. + let r = std::panic::catch_unwind(|| unsafe { rusty_alloc::prim::alloc(64, 0, true, false) }); + assert!(r.is_ok(), "prim::alloc(align=0) panicked"); + assert!(r.unwrap().is_err()); + // SAFETY: as above, with a non-power-of-two alignment. + let r = std::panic::catch_unwind(|| unsafe { rusty_alloc::prim::alloc(64, 3, true, false) }); + assert!(r.is_ok(), "prim::alloc(align=3) panicked"); + assert!(r.unwrap().is_err()); +} + +/// F-01: `huge_alloc` garbage align is Err, not `debug_assert!` +/// (OH-rusty_alloc-39). +#[test] +fn oh_f01_huge_alloc_bad_align_is_err() { + let r = std::panic::catch_unwind(|| rusty_alloc::segment::huge_alloc(64, 0, 0, -1)); + assert!(r.is_ok(), "huge_alloc(align=0) panicked"); + assert!(r.unwrap().is_err()); + let r = std::panic::catch_unwind(|| { + rusty_alloc::segment::huge_alloc(64, rusty_alloc::types::SEGMENT_SIZE, 0, -1) + }); + assert!(r.is_ok(), "huge_alloc(align=SEGMENT) panicked"); + assert!(r.unwrap().is_err()); +} + +/// F-01 / F-04: in-place `realloc_aligned_at` huge offset is null; original +/// lives (OH-rusty_alloc-42). +#[test] +fn oh_f04_realloc_inplace_huge_offset_is_null() { + use rusty_alloc::alloc::{realloc_aligned_at, usable_size}; + let p = malloc(64); + assert!(!p.is_null()); + // SAFETY: `p` is a live 64-byte block of ours; the realloc keeps it live + // (it must refuse), and it is freed once at the end. + unsafe { + p.write(0x42); + let u = usable_size(p); + let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + realloc_aligned_at(p, u, 8, usize::MAX) + })); + assert!(r.is_ok(), "realloc_aligned_at in-place MAX offset panicked"); + assert!(r.unwrap().is_null()); + assert_eq!(p.read(), 0x42); + free(p); + } +} + +/// F-01 / F-04: in-place `rezalloc_aligned_at` huge offset is null +/// (OH-rusty_alloc-43). +#[test] +fn oh_f04_rezalloc_inplace_huge_offset_is_null() { + use rusty_alloc::alloc::{rezalloc_aligned_at, usable_size, zalloc}; + let p = zalloc(64); + assert!(!p.is_null()); + // SAFETY: as the realloc twin above. + unsafe { + let u = usable_size(p); + let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + rezalloc_aligned_at(p, u, 8, usize::MAX) + })); + assert!( + r.is_ok(), + "rezalloc_aligned_at in-place MAX offset panicked" + ); + assert!(r.unwrap().is_null()); + free(p); + } +} + +/// F-01: `prim::commit(null)` is Err, not a fresh OS mapping +/// (OH-rusty_alloc-60). +#[test] +fn oh_f01_prim_commit_null_is_err() { + let ps = rusty_alloc::os::page_size(); + // SAFETY: the OS wrapper is handed null; the assertion is that it refuses + // before any syscall (it used to hand Windows an untracked mapping). + let r = std::panic::catch_unwind(|| unsafe { + rusty_alloc::prim::commit(core::ptr::null_mut(), ps) + }); + assert!(r.is_ok(), "prim::commit(null) panicked"); + assert!(r.unwrap().is_err(), "prim::commit(null) succeeded"); +} + +/// F-01: `malloc_small(MAX)` is null, not a debug_assert (OH-rusty_alloc-62). +#[test] +fn oh_f01_malloc_small_max_is_null() { + let r = std::panic::catch_unwind(|| rusty_alloc::alloc::malloc_small(usize::MAX)); + assert!(r.is_ok(), "malloc_small(MAX) panicked"); + assert!(r.unwrap().is_null()); + let r = std::panic::catch_unwind(|| rusty_alloc::alloc::zalloc_small(usize::MAX)); + assert!(r.is_ok(), "zalloc_small(MAX) panicked"); + assert!(r.unwrap().is_null()); +} + +/// F-05: `manage_os_memory_ex(0x8, 2*SEGMENT)` is Err (OH-rusty_alloc-115). +#[test] +fn oh_f05_manage_os_memory_garbage_base_is_err() { + let r = rusty_alloc::arena::manage_os_memory_ex( + 8usize as *mut u8, + rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2), + true, + false, + false, + -1, + false, + ); + assert!(r.is_err()); +} + +/// F-05: a high unmapped start is not an arena (OH-rusty_alloc-201). +#[test] +fn oh_f05_manage_os_memory_unmapped_is_err() { + let unmapped = 1usize << 40; + let r = rusty_alloc::arena::manage_os_memory_ex( + unmapped as *mut u8, + rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2), + true, + false, + false, + -1, + false, + ); + assert!(r.is_err()); + let r = rusty_alloc::arena::manage_os_memory_ex( + (unmapped + 8) as *mut u8, + rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2), + true, + false, + false, + -1, + false, + ); + assert!(r.is_err()); +} + +/// F-05: a live segment window is not caller memory (OH-rusty_alloc-202). +#[test] +fn oh_f05_manage_os_memory_live_window_is_err() { + let p = malloc(16); + assert!(!p.is_null()); + let seg = rusty_alloc::segment::segment_of(p); + let r = rusty_alloc::arena::manage_os_memory_ex( + seg.cast(), + rusty_alloc::types::SEGMENT_SIZE, + true, + false, + false, + -1, + false, + ); + assert!(r.is_err()); + // SAFETY: `p` is a live 16-byte block of ours, untouched by the refused + // adoption; freed once. + unsafe { + p.write(0x62); + assert_eq!(p.read(), 0x62); + free(p); + } +} + +/// F-05: a real OS reservation is still adoptable (OH-rusty_alloc-201/202). +#[test] +fn oh_f05_manage_os_memory_real_block_still_works() { + let b = rusty_alloc::os::alloc_aligned( + rusty_alloc::types::SEGMENT_SIZE.saturating_mul(2), + rusty_alloc::types::SEGMENT_SIZE, + true, + false, + ) + .expect("os block"); + let id = rusty_alloc::arena::manage_os_memory_ex(b.ptr, b.size, true, false, false, -1, false) + .expect("manage real block"); + let (base, sz) = rusty_alloc::arena::arena_area(id); + assert_eq!(base, b.ptr); + assert!(sz >= rusty_alloc::types::SEGMENT_SIZE); +} diff --git a/crates/rusty_alloc_ffi/src/lib.rs b/crates/rusty_alloc_ffi/src/lib.rs index d1e57b5..64240ed 100644 --- a/crates/rusty_alloc_ffi/src/lib.rs +++ b/crates/rusty_alloc_ffi/src/lib.rs @@ -23,6 +23,24 @@ use core::ffi::{c_int, c_void}; use rusty_alloc::alloc; +/// A null or misaligned out-parameter is not caller storage: a write through +/// it is UB, so the call refuses it instead (OH-rusty_alloc-97…). Shape only — +/// what a well-formed pointer points at is the C caller's, as for `free`. +#[inline] +fn out_mut(p: *mut T) -> *mut T { + if p.is_null() || p.addr() & (core::mem::align_of::() - 1) != 0 { + core::ptr::null_mut() + } else { + p + } +} + +/// A null / misaligned C string is not readable input (OH-rusty_alloc-105…). +#[inline] +fn cstr_in(p: *const T) -> *const T { + out_mut(p.cast_mut()).cast_const() +} + /// mimalloc ABI: `int mi_version(void)` — 20405 = v2.4.5 compatibility. #[unsafe(no_mangle)] pub extern "C" fn mi_version() -> c_int { @@ -166,6 +184,7 @@ pub unsafe extern "C" fn mi_expand(p: *mut c_void, newsize: usize) -> *mut c_voi /// C contract: `s` is null or a valid NUL-terminated string. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_strdup(s: *const core::ffi::c_char) -> *mut core::ffi::c_char { + let s = cstr_in(s); if s.is_null() { return core::ptr::null_mut(); } @@ -190,6 +209,7 @@ pub unsafe extern "C" fn mi_strndup( s: *const core::ffi::c_char, n: usize, ) -> *mut core::ffi::c_char { + let s = cstr_in(s); if s.is_null() { return core::ptr::null_mut(); } @@ -413,8 +433,10 @@ pub unsafe extern "C" fn mi_recalloc_aligned_at( // --------------------------------------------------------------------------- unsafe fn store_bs(out: *mut usize, p: *mut u8) { + let out = out_mut(out); if !out.is_null() { - // SAFETY: caller passed a valid out-pointer (C contract); p null → 0. + // SAFETY: out is plausible caller storage; p null → 0. + // A first-page lie used to AV (OH-rusty_alloc-99). unsafe { out.write(if p.is_null() { 0 @@ -466,6 +488,7 @@ pub unsafe extern "C" fn mi_urealloc( ) -> *mut c_void { // SAFETY: forwarded C contract throughout. unsafe { + let block_size_pre = out_mut(block_size_pre); if !block_size_pre.is_null() { block_size_pre.write(alloc::usable_size(p.cast())); } @@ -483,6 +506,7 @@ pub unsafe extern "C" fn mi_urealloc( pub unsafe extern "C" fn mi_ufree(p: *mut c_void, block_size: *mut usize) { // SAFETY: forwarded C contract; usable read before the free. unsafe { + let block_size = out_mut(block_size); if !block_size.is_null() { block_size.write(alloc::usable_size(p.cast())); } @@ -645,7 +669,10 @@ pub unsafe fn posix_memalign_impl(out: *mut *mut c_void, alignment: usize, size: // `x & (x - 1)` test; establishing `alignment >= size_of::<*mut _>()` // first makes the non-zero half redundant, so the second test reduces to // the single `and`. Same predicate, measured cheaper. + let out = out_mut(out); if out.is_null() || alignment < core::mem::size_of::<*mut c_void>() { + // A first-page lie used to malloc then write through 0x8 + // (OH-rusty_alloc-97). return einval(); } if alignment & (alignment - 1) != 0 { @@ -701,10 +728,11 @@ pub unsafe extern "C" fn mi_reallocarray(p: *mut c_void, count: usize, size: usi /// `ptrp` must be a valid pointer-to-pointer; `*ptrp` as [`mi_realloc`]. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_reallocarr(ptrp: *mut c_void, count: usize, size: usize) -> c_int { - if ptrp.is_null() { + let slot: *mut *mut c_void = out_mut(ptrp.cast()); + if slot.is_null() { + // A first-page lie used to read/write through 0x8 (OH-rusty_alloc-98). return 22; // EINVAL } - let slot: *mut *mut c_void = ptrp.cast(); // SAFETY: slot valid per contract; realloc contract forwarded. unsafe { let np = alloc::reallocn((*slot).cast(), count, size); @@ -747,18 +775,18 @@ pub unsafe extern "C" fn mi_aligned_offset_recalloc( unsafe { alloc::recalloc_aligned_at(p.cast(), newcount, size, alignment, offset).cast() } } -/// `mi_free_size(p, size)` — sized free (fast-path exploitation is an M8 -/// brick; the size is verified under debug). +/// `mi_free_size(p, size)` — sized free (the size is unused for the actual +/// free; a lie is ignored, not an abort — OH-rusty_alloc-65). /// /// # Safety /// As [`mi_free`]; `size` ≤ the block's usable size. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_free_size(p: *mut c_void, size: usize) { + let _ = size; + // A lying size is ignored, not a debug_assert abort across extern "C" + // (OH-rusty_alloc-65). The size is unused for the actual free. // SAFETY: forwarded C contract. - unsafe { - debug_assert!(p.is_null() || size <= alloc::usable_size(p.cast())); - alloc::free(p.cast()); - } + unsafe { alloc::free(p.cast()) }; } /// `mi_free_size_aligned`. @@ -767,8 +795,9 @@ pub unsafe extern "C" fn mi_free_size(p: *mut c_void, size: usize) { /// As [`mi_free_size`]; `p` must satisfy the alignment. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_free_size_aligned(p: *mut c_void, size: usize, alignment: usize) { - debug_assert!(p.is_null() || (p as usize).is_multiple_of(alignment.max(1))); - // SAFETY: forwarded C contract. + let _ = alignment; + // SAFETY: forwarded C contract. Alignment is unused for the free + // (OH-rusty_alloc-66). unsafe { mi_free_size(p, size) }; } @@ -778,7 +807,9 @@ pub unsafe extern "C" fn mi_free_size_aligned(p: *mut c_void, size: usize, align /// As [`mi_free`]; `p` must satisfy the alignment. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_free_aligned(p: *mut c_void, alignment: usize) { - debug_assert!(p.is_null() || (p as usize).is_multiple_of(alignment.max(1))); + let _ = alignment; + // A garbage alignment is a free, not a debug_assert abort across + // extern "C" (OH-rusty_alloc-66). // SAFETY: forwarded C contract. unsafe { alloc::free(p.cast()) }; } @@ -844,6 +875,12 @@ pub unsafe extern "C" fn mi_heap_destroy(heap: *mut MiHeap) { /// `heap` live and owned by the calling thread. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_heap_set_default(heap: *mut MiHeap) -> *mut MiHeap { + // A null / misaligned handle or the immortal empty box is refused, not + // installed: the next `malloc` on this thread would dereference it. + let heap = out_mut(heap); + if heap.is_null() || heap == rusty_alloc::init::empty_heap_box_ptr() { + return rusty_alloc::init::heap_box(); + } // SAFETY: forwarded C contract. unsafe { rusty_alloc::init::set_default_heap(heap) } } @@ -1005,6 +1042,7 @@ pub unsafe extern "C" fn mi_heap_strdup( heap: *mut MiHeap, s: *const core::ffi::c_char, ) -> *mut core::ffi::c_char { + let s = cstr_in(s); if s.is_null() { return core::ptr::null_mut(); } @@ -1029,6 +1067,7 @@ pub unsafe extern "C" fn mi_heap_strndup( s: *const core::ffi::c_char, n: usize, ) -> *mut core::ffi::c_char { + let s = cstr_in(s); if s.is_null() { return core::ptr::null_mut(); } @@ -1178,7 +1217,7 @@ pub unsafe extern "C" fn mi_heap_realloc_aligned_at( let usable = alloc::usable_size(p.cast()); if newsize <= usable && newsize >= usable / 2 - && rusty_alloc::bins::is_aligned_to(p as usize + offset, alignment) + && rusty_alloc::bins::is_aligned_at(p as usize, offset, alignment) { return p; } @@ -1263,7 +1302,7 @@ pub unsafe extern "C" fn mi_heap_rezalloc_aligned_at( let usable = alloc::usable_size(p.cast()); if newsize <= usable && newsize >= usable / 2 - && rusty_alloc::bins::is_aligned_to(p as usize + offset, alignment) + && rusty_alloc::bins::is_aligned_at(p as usize, offset, alignment) { return p; } @@ -1425,6 +1464,21 @@ fn area_to_c(a: &rusty_alloc::heap::AreaInfo) -> MiHeapArea { } } +/// Null / misaligned / the empty sentinel is not a heap +/// (OH-rusty_alloc-58 / 77). +#[inline] +unsafe fn heap_ptr(heap: *mut MiHeap) -> *mut rusty_alloc::heap::Heap { + // Null, misaligned, or the immortal empty box is "no heap". A well-formed + // handle is the caller's live heap per the C contract — the same trust + // `free` extends to a pointer it is handed. + let heap = out_mut(heap); + if heap.is_null() || heap == rusty_alloc::init::empty_heap_box_ptr() { + return core::ptr::null_mut(); + } + // SAFETY: non-null, aligned, not the immortal empty box. + unsafe { (*heap).heap.get() } +} + /// `mi_heap_visit_blocks`. /// /// # Safety @@ -1438,9 +1492,12 @@ pub unsafe extern "C" fn mi_heap_visit_blocks( ) -> bool { let Some(vf) = visitor else { return true }; // SAFETY: forwarded C contracts; adapter re-wraps areas per call. + // A null / empty heap is "walk finished", not an abort (OH-rusty_alloc-58). unsafe { - let h = (*heap.cast_mut()).heap.get(); - (*h).visit_blocks(visit_blocks, &mut |area, block, bsize| { + let Some(h) = heap_ptr(heap.cast_mut()).as_mut() else { + return true; + }; + h.visit_blocks(visit_blocks, &mut |area, block, bsize| { let ca = area_to_c(area); vf(heap, &ca, block.cast(), bsize, arg) }) @@ -1482,8 +1539,13 @@ pub unsafe extern "C" fn mi_unsafe_heap_page_is_under_utilized( p: *mut c_void, perc_threshold: usize, ) -> bool { - // SAFETY: forwarded C contract. - unsafe { (*(*heap).heap.get()).page_under_utilized(p.cast(), perc_threshold) } + // SAFETY: forwarded C contract. Null / empty is false (OH-rusty_alloc-58). + unsafe { + let Some(h) = heap_ptr(heap).as_mut() else { + return false; + }; + h.page_under_utilized(p.cast(), perc_threshold) + } } /// `mi_reserve_os_memory` / `_ex`. @@ -1509,8 +1571,9 @@ pub unsafe extern "C" fn mi_reserve_os_memory_ex( ) -> c_int { match rusty_alloc::arena::reserve_os_memory_ex(size, commit, allow_large, exclusive) { Ok(id) => { + let arena_id = out_mut(arena_id); if !arena_id.is_null() { - // SAFETY: out-pointer valid per contract. + // SAFETY: out-pointer is plausible caller storage. unsafe { arena_id.write(id) }; } 0 @@ -1570,8 +1633,9 @@ pub unsafe extern "C" fn mi_manage_os_memory_ex( exclusive, ) { Ok(id) => { + let arena_id = out_mut(arena_id); if !arena_id.is_null() { - // SAFETY: out-pointer valid per contract. + // SAFETY: out-pointer is plausible caller storage. unsafe { arena_id.write(id) }; } true @@ -1587,22 +1651,34 @@ pub unsafe extern "C" fn mi_manage_os_memory_ex( #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_arena_area(arena_id: c_int, size: *mut usize) -> *mut c_void { let (p, s) = rusty_alloc::arena::arena_area(arena_id); + let size = out_mut(size); if !size.is_null() { - // SAFETY: out-pointer valid per contract. + // SAFETY: out-pointer is plausible caller storage + // (OH-rusty_alloc-100). unsafe { size.write(s) }; } p.cast() } +const HUGE_OS_PAGE: usize = 1 << 30; + +fn huge_os_pages_bytes(pages: usize) -> Option { + pages.checked_mul(HUGE_OS_PAGE) +} + /// `mi_reserve_huge_os_pages_at` (+ `_ex`, `_interleave`, deprecated form): /// large-page arena reservations; NUMA placement recorded, not enforced (v1). +/// Unsatisfiable `pages` is ENOMEM, not `pages * 1GiB` overflow (OH-rusty_alloc-14). #[unsafe(no_mangle)] pub extern "C" fn mi_reserve_huge_os_pages_at( pages: usize, _numa_node: c_int, _timeout_msecs: usize, ) -> c_int { - mi_reserve_os_memory(pages * (1 << 30), true, true) + match huge_os_pages_bytes(pages) { + Some(n) => mi_reserve_os_memory(n, true, true), + None => 12, + } } /// `mi_reserve_huge_os_pages_at_ex`. @@ -1617,8 +1693,11 @@ pub unsafe extern "C" fn mi_reserve_huge_os_pages_at_ex( exclusive: bool, arena_id: *mut c_int, ) -> c_int { - // SAFETY: forwarded out-pointer contract. - unsafe { mi_reserve_os_memory_ex(pages * (1 << 30), true, true, exclusive, arena_id) } + match huge_os_pages_bytes(pages) { + // SAFETY: forwarded out-pointer contract. + Some(n) => unsafe { mi_reserve_os_memory_ex(n, true, true, exclusive, arena_id) }, + None => 12, + } } /// `mi_reserve_huge_os_pages_interleave`. @@ -1628,7 +1707,10 @@ pub extern "C" fn mi_reserve_huge_os_pages_interleave( _numa_nodes: usize, _timeout: usize, ) -> c_int { - mi_reserve_os_memory(pages * (1 << 30), true, true) + match huge_os_pages_bytes(pages) { + Some(n) => mi_reserve_os_memory(n, true, true), + None => 12, + } } /// deprecated `mi_reserve_huge_os_pages`. @@ -1641,9 +1723,14 @@ pub unsafe extern "C" fn mi_reserve_huge_os_pages( _max_secs: f64, pages_reserved: *mut usize, ) -> c_int { - let r = mi_reserve_os_memory(pages * (1 << 30), true, true); + let r = match huge_os_pages_bytes(pages) { + Some(n) => mi_reserve_os_memory(n, true, true), + None => 12, + }; + let pages_reserved = out_mut(pages_reserved); if !pages_reserved.is_null() { - // SAFETY: out-pointer valid per contract. + // SAFETY: out-pointer is plausible caller storage + // (OH-rusty_alloc-102). unsafe { pages_reserved.write(if r == 0 { pages } else { 0 }) }; } r @@ -1885,6 +1972,7 @@ pub unsafe extern "C" fn mi_process_info( // SAFETY: each out-pointer valid-or-null per contract. unsafe { let w = |p: *mut usize, v: usize| { + let p = out_mut(p); if !p.is_null() { p.write(v) } @@ -1910,8 +1998,12 @@ pub unsafe extern "C" fn mi_heap_guarded_set_sample_rate( sample_rate: usize, seed: usize, ) { - // SAFETY: forwarded C contract. - unsafe { (*(*heap).heap.get()).guarded_set_sample_rate(sample_rate, seed) }; + // SAFETY: forwarded C contract. Null / empty is a no-op (OH-rusty_alloc-58). + unsafe { + if let Some(h) = heap_ptr(heap).as_mut() { + h.guarded_set_sample_rate(sample_rate, seed); + } + } } /// `mi_heap_guarded_set_size_bound`. @@ -1920,8 +2012,12 @@ pub unsafe extern "C" fn mi_heap_guarded_set_sample_rate( /// `heap` live and owned by the calling thread. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_heap_guarded_set_size_bound(heap: *mut MiHeap, min: usize, max: usize) { - // SAFETY: forwarded C contract. - unsafe { (*(*heap).heap.get()).guarded_set_size_bound(min, max) }; + // SAFETY: forwarded C contract. Null / empty is a no-op (OH-rusty_alloc-58). + unsafe { + if let Some(h) = heap_ptr(heap).as_mut() { + h.guarded_set_size_bound(min, max); + } + } } /// `mi_is_redirected` (Windows redirection is post-v1). @@ -2054,6 +2150,11 @@ pub unsafe extern "C" fn mi_new_reallocn( } } +/// Caller-provided `mi_realpath` storage is PATH_MAX bytes (MAX_PATH on +/// Windows). A longer canonical path, or a smash past a short slot, is null — +/// never an unbounded copy (OH-rusty_alloc-26). +const REALPATH_MAX: usize = if cfg!(windows) { 260 } else { 4096 }; + /// `mi_realpath`: resolve to an absolute canonical path into allocated (or /// caller-provided) storage. /// @@ -2065,7 +2166,11 @@ pub unsafe extern "C" fn mi_realpath( fname: *const core::ffi::c_char, resolved_name: *mut core::ffi::c_char, ) -> *mut core::ffi::c_char { - if fname.is_null() { + let fname = cstr_in(fname); + let raw_out = resolved_name; + let resolved_name = out_mut(resolved_name); + if fname.is_null() || (!raw_out.is_null() && resolved_name.is_null()) { + // Lying fname / out used to AV (OH-rusty_alloc-111 / 112). return core::ptr::null_mut(); } // SAFETY: fname NUL-terminated per contract. @@ -2076,6 +2181,9 @@ pub unsafe extern "C" fn mi_realpath( return core::ptr::null_mut(); }; let bytes = canon.to_string_lossy().into_owned().into_bytes(); + if !resolved_name.is_null() && bytes.len() >= REALPATH_MAX { + return core::ptr::null_mut(); + } let out = if resolved_name.is_null() { alloc::malloc(bytes.len() + 1) } else { @@ -2103,7 +2211,21 @@ pub unsafe extern "C" fn mi_dupenv_s( size: *mut usize, name: *const core::ffi::c_char, ) -> c_int { + let buf = out_mut(buf); + let size = out_mut(size); + let name = cstr_in(name); if buf.is_null() || name.is_null() { + // Fail-closed outs on EINVAL (OH-rusty_alloc-16). + // A first-page name used to AV in CStr::from_ptr (OH-rusty_alloc-113). + if !buf.is_null() { + // SAFETY: `buf` passed `out_mut` (non-null, aligned); the CRT + // contract makes it writable. + unsafe { buf.write(core::ptr::null_mut()) }; + } + if !size.is_null() { + // SAFETY: as `buf`. + unsafe { size.write(0) }; + } return 22; } // SAFETY: name NUL-terminated per contract; out-pointers valid. @@ -2141,6 +2263,7 @@ pub unsafe extern "C" fn mi_dupenv_s( /// `s` null or NUL-terminated wide string. #[unsafe(no_mangle)] pub unsafe extern "C" fn mi_wcsdup(s: *const u16) -> *mut u16 { + let s = cstr_in(s); if s.is_null() { return core::ptr::null_mut(); } @@ -2177,7 +2300,19 @@ pub unsafe extern "C" fn mi_wdupenv_s( size: *mut usize, name: *const u16, ) -> c_int { + let buf = out_mut(buf); + let size = out_mut(size); + let name = cstr_in(name); if buf.is_null() || name.is_null() { + if !buf.is_null() { + // SAFETY: `buf` passed `out_mut` (non-null, aligned); the CRT + // contract makes it writable. + unsafe { buf.write(core::ptr::null_mut()) }; + } + if !size.is_null() { + // SAFETY: as `buf`. + unsafe { size.write(0) }; + } return 22; } // SAFETY: contracts as documented. diff --git a/crates/rusty_alloc_ffi/tests/openheimer.rs b/crates/rusty_alloc_ffi/tests/openheimer.rs new file mode 100644 index 0000000..a887dc2 --- /dev/null +++ b/crates/rusty_alloc_ffi/tests/openheimer.rs @@ -0,0 +1,216 @@ +//! Openheimer regressions for the C ABI crate (OH-14, OH-16). + +use std::panic::{AssertUnwindSafe, catch_unwind}; + +use rusty_alloc_ffi::{ + mi_arena_area, mi_dupenv_s, mi_free, mi_heap_get_default, mi_heap_guarded_set_sample_rate, + mi_heap_guarded_set_size_bound, mi_heap_realloc_aligned_at, mi_heap_rezalloc_aligned_at, + mi_heap_strdup, mi_heap_strndup, mi_heap_visit_blocks, mi_heap_zalloc, mi_malloc, mi_mbsdup, + mi_posix_memalign, mi_process_info, mi_reallocarr, mi_realpath, mi_reserve_huge_os_pages, + mi_reserve_huge_os_pages_at, mi_reserve_huge_os_pages_interleave, mi_strdup, mi_strndup, + mi_umalloc, mi_unsafe_heap_page_is_under_utilized, mi_usable_size, mi_wcsdup, mi_wdupenv_s, +}; + +/// F-04: `pages * 1GiB` must not overflow (OH-rusty_alloc-14). +#[test] +fn oh_f04_reserve_huge_os_pages_overflow_is_enomem() { + let r = catch_unwind(|| mi_reserve_huge_os_pages_at(usize::MAX, -1, 0)); + assert!(r.is_ok(), "mi_reserve_huge_os_pages_at(MAX) panicked"); + assert_eq!(r.unwrap(), 12); + assert_eq!(mi_reserve_huge_os_pages_interleave(usize::MAX, 0, 0), 12); + // SAFETY: the out-pointer is a live local. + unsafe { + let mut reserved = 0x1111_usize; + assert_eq!(mi_reserve_huge_os_pages(usize::MAX, 0.0, &mut reserved), 12); + assert_eq!(reserved, 0); + } +} + +/// F-01: EINVAL on `dupenv` clears the caller's out-pointers (OH-rusty_alloc-16). +#[test] +fn oh_f01_dupenv_einval_clears_outs() { + // SAFETY: both out-pointers are live locals; the name is null, which the + // entry must refuse with EINVAL before reading anything. + unsafe { + let mut buf: *mut i8 = core::ptr::NonNull::::dangling().as_ptr(); + let mut sz = 99usize; + assert_eq!(mi_dupenv_s(&mut buf, &mut sz, core::ptr::null()), 22); + assert!(buf.is_null()); + assert_eq!(sz, 0); + let mut wbuf: *mut u16 = core::ptr::NonNull::::dangling().as_ptr(); + sz = 99; + assert_eq!(mi_wdupenv_s(&mut wbuf, &mut sz, core::ptr::null()), 22); + assert!(wbuf.is_null()); + assert_eq!(sz, 0); + } +} + +/// F-05: `mi_realpath` must not write past PATH_MAX (OH-rusty_alloc-26). +#[test] +fn oh_f05_realpath_does_not_write_past_path_max() { + const PATH_MAX: usize = if cfg!(windows) { 260 } else { 4096 }; + let mut buf = vec![0u8; PATH_MAX + 16]; + buf[PATH_MAX..].fill(0xA5); + // SAFETY: a NUL-terminated path and a buffer of more than PATH_MAX bytes, + // whose tail is checked afterwards. + unsafe { + let _ = mi_realpath(c".".as_ptr(), buf.as_mut_ptr().cast()); + } + assert!( + buf[PATH_MAX..].iter().all(|&b| b == 0xA5), + "realpath wrote past PATH_MAX" + ); +} + +/// F-01 / F-04: heap-relative in-place realloc huge offset is null; original +/// lives (OH-rusty_alloc-44). extern "C" cannot unwind, so this must not panic. +#[test] +fn oh_f04_heap_realloc_inplace_huge_offset_is_null() { + let h = mi_heap_get_default(); + // SAFETY: `h` is this thread's live heap; `p` is a live block of it that + // the refused realloc leaves live, freed once. + unsafe { + let p = mi_malloc(64); + assert!(!p.is_null()); + p.cast::().write(0x43); + let u = mi_usable_size(p); + let np = mi_heap_realloc_aligned_at(h, p, u, 8, usize::MAX); + assert!(np.is_null()); + assert_eq!(p.cast::().read(), 0x43); + mi_free(p); + } +} + +/// F-01 / F-04: heap-relative in-place rezalloc huge offset is null +/// (OH-rusty_alloc-45). +#[test] +fn oh_f04_heap_rezalloc_inplace_huge_offset_is_null() { + let h = mi_heap_get_default(); + // SAFETY: as the realloc twin above. + unsafe { + let p = mi_heap_zalloc(h, 64); + assert!(!p.is_null()); + let u = mi_usable_size(p); + let np = mi_heap_rezalloc_aligned_at(h, p, u, 8, usize::MAX); + assert!(np.is_null()); + mi_free(p); + } +} + +/// F-01: `mi_heap_visit_blocks(null)` is true, not an abort +/// (OH-rusty_alloc-58). extern "C" cannot unwind. +#[test] +fn oh_f01_heap_visit_blocks_null_is_total() { + unsafe extern "C" fn visit_ok( + _h: *const rusty_alloc_ffi::MiHeap, + _a: *const rusty_alloc_ffi::MiHeapArea, + _b: *mut core::ffi::c_void, + _n: usize, + _arg: *mut core::ffi::c_void, + ) -> bool { + true + } + // SAFETY: every heap handle is null, which each entry must treat as "no + // heap"; the visitor is a valid function that touches nothing. + unsafe { + assert!(mi_heap_visit_blocks( + core::ptr::null(), + true, + Some(visit_ok), + core::ptr::null_mut() + )); + assert!(!mi_unsafe_heap_page_is_under_utilized( + core::ptr::null_mut(), + core::ptr::null_mut(), + 50 + )); + mi_heap_guarded_set_sample_rate(core::ptr::null_mut(), 1, 0); + mi_heap_guarded_set_size_bound(core::ptr::null_mut(), 0, 64); + } +} + +/// F-01: a null or misaligned out-parameter is refused, not written +/// (OH-rusty_alloc-97…102). extern "C" cannot unwind, so none of these may +/// panic either. +#[test] +fn oh_f01_ffi_out_param_null_or_misaligned_is_refused() { + // `*mut *mut c_void` / `*mut usize` are 8-aligned on every target we + // ship; an odd address is misaligned for all of them. + let odd = 0x1001usize; + // SAFETY: every out-pointer handed in is null or misaligned, which each + // entry must refuse before writing; `p` is a block `mi_umalloc` returned, + // freed once. + unsafe { + let r = catch_unwind(|| mi_posix_memalign(core::ptr::null_mut(), 16, 32)); + assert!(r.is_ok() && r.unwrap() == 22); + let r = catch_unwind(|| mi_posix_memalign(odd as *mut _, 16, 32)); + assert!(r.is_ok() && r.unwrap() == 22); + let r = catch_unwind(|| mi_reallocarr(core::ptr::null_mut(), 1, 8)); + assert!(r.is_ok() && r.unwrap() == 22); + let r = catch_unwind(|| mi_reallocarr(odd as *mut _, 1, 8)); + assert!(r.is_ok() && r.unwrap() == 22); + let r = catch_unwind(|| mi_umalloc(16, odd as *mut _)); + assert!(r.is_ok()); + let p = r.unwrap(); + assert!(!p.is_null()); + mi_free(p); + let r = catch_unwind(|| mi_arena_area(0, odd as *mut _)); + assert!(r.is_ok()); + let r = catch_unwind(|| { + mi_process_info( + odd as *mut _, + core::ptr::null_mut(), + odd as *mut _, + core::ptr::null_mut(), + odd as *mut _, + core::ptr::null_mut(), + odd as *mut _, + core::ptr::null_mut(), + ) + }); + assert!(r.is_ok()); + let r = catch_unwind(|| mi_reserve_huge_os_pages(usize::MAX, 0.0, odd as *mut _)); + assert!(r.is_ok() && r.unwrap() == 12); + } +} +/// F-01: a null C-string / path input is null / EINVAL, not a read through +/// null (OH-rusty_alloc-105…114). extern "C" cannot unwind. +#[test] +fn oh_f01_ffi_cstr_null_is_refused() { + let h = mi_heap_get_default(); + // SAFETY: every string / path handed in is null or misaligned, which each + // entry must refuse before reading; `h` is this thread's live heap; the + // dupenv out-pointers are live locals. + unsafe { + let r = catch_unwind(|| mi_strdup(core::ptr::null())); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(|| mi_strndup(core::ptr::null(), 16)); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(|| mi_wcsdup(core::ptr::null())); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(|| mi_mbsdup(core::ptr::null())); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(AssertUnwindSafe(|| mi_heap_strdup(h, core::ptr::null()))); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(AssertUnwindSafe(|| { + mi_heap_strndup(h, core::ptr::null(), 16) + })); + assert!(r.is_ok() && r.unwrap().is_null()); + let r = catch_unwind(|| mi_realpath(core::ptr::null(), core::ptr::null_mut())); + assert!(r.is_ok() && r.unwrap().is_null()); + let mut buf = core::ptr::null_mut(); + let mut size = 0usize; + let r = catch_unwind(AssertUnwindSafe(|| { + mi_dupenv_s(&mut buf, &mut size, core::ptr::null()) + })); + assert!(r.is_ok() && r.unwrap() == 22); + let mut wbuf = core::ptr::null_mut(); + let r = catch_unwind(AssertUnwindSafe(|| { + mi_wdupenv_s(&mut wbuf, &mut size, core::ptr::null()) + })); + assert!(r.is_ok() && r.unwrap() == 22); + // A misaligned wide string is not readable input either. + let r = catch_unwind(|| mi_wcsdup(0x1001usize as *const _)); + assert!(r.is_ok() && r.unwrap().is_null()); + } +} diff --git a/docs/LEDGER.md b/docs/LEDGER.md index 0a81053..a4eb507 100644 --- a/docs/LEDGER.md +++ b/docs/LEDGER.md @@ -4,6 +4,77 @@ One entry per milestone/brick: what landed, the numbers with their method lines, what was reverted and **which kind** of revert (measured-worse vs within-noise). Newest first. +## OPENHEIMER, SPLIT — 202 findings, 139 withdrawn as hot-path tax; the one fix the log claimed and never wrote (2026-09-16) + +`docs/plans/openheimer-run.md`, from the campaign's red log +(`openheimer/docs/results/rusty_alloc_openheimer_results.md`, 202 findings, +140 rated High, 1,395 lines of uncommitted diff). The brief was: keep what +stops a hostile request at the door, drop what taxes the allocator. + +**What the log was.** 63 findings are real: checked arithmetic on a size, +alignment, offset or option value a caller can choose (OH-5..34, 42..45); +`manage_os_memory` adopting null / wrapped / unmapped / already-ours ranges +(OH-15, 201, 202); hook re-entry (OH-17, 23, 24); `debug_checks` compiled out +of the build it exists for (OH-7); C-ABI out-pointers, strings and handles +(OH-16, 26, 54, 58, 65, 66, 97..102); thread exit leaking first-class heaps +(OH-13). The other 139 are ONE probe — an internal `unsafe fn` handed null, +`0x1`, or `floor + 8` — chased through 25 helpers and up a ladder of six +floors, then "closed" with a segment-map membership lookup on every internal +handle. OH-103..200 are that ladder: the same probe re-filed per constant. + +**Why they were withdrawn, with the numbers the campaign never took.** Those +guards check contracts the caller in this crate already upholds and duplicate +R-001 (release `free` trusts its window). At the campaign's stopping point, +x86-64 release assembly against 2.2.0: `free` **+27**, `realloc` **+164**, +`page_extend` **+68** instructions — `box_of_xheap` walked the heap registry +under a global lock on the free path. Three of its High-severity regression +tests failed on its own branch (exit 97: the second free RETURNED), because +the OH-11 fix the log describes was never written (`git diff | grep -c +xthread_free` = 0). + +**What landed, measured.** Method: `cargo rustc --release --lib -- --emit asm` +for main (a worktree) and the branch, same toolchain, per-symbol instruction +counts, Windows x86-64 and `x86_64-unknown-linux-gnu`. + +| symbol | main → branch (win) | (linux) | where the delta is | +|---|---:|---:|---| +| `alloc::free` | 62 → 66 | 63 → 67 | two `cmp; je` on the cross-thread arm; local path byte-identical, no frame | +| `alloc::malloc` / `malloc_aligned_at` | 0 / 0 | 0 / 0 | untouched | +| `alloc::realloc` | +7 | +6 | inlined `free`'s remote arm | +| `alloc::realloc_aligned_at` | +1 | +1 | was +43 until `is_aligned_to` stopped using `is_power_of_two()` (a SWAR popcount without `popcnt`) | +| `page::page_extend` / `usable_size` | 0 / 0 | 0 / 0 | untouched | +| `page::remote_free` | +4 | +4 | the two compares | +| `segment::huge_alloc` | +29 | −14 | cold: align check, checked `header + size`, checked placement | + +**The fix that was owed (OH-11), and what it turned up.** The README says a +double free aborts on both paths. The cross-thread arm compared the drained +chain's length against `used` AFTER walking the chain — and a remote double +free makes the chain CYCLIC, so the walk never returned: the owner's next +collect hung, and on an abandoned page the next reclaim did. That check was +unreachable for the one input it named. Now: `remote_free` refuses a block +that is already the chain head (push time, consecutive case), and the collect +walk aborts once `n > used` (interleaved A-B-A). Getting the push-time check +onto `free` for free took three tries, recorded in `page::remote_double_free`: +a diverging callee is `call; ud2`, and one `call` pins a frame to the top of +`free` on Windows x64 (SEH cannot describe a prologue elsewhere, so +shrink-wrapping is off) — +2 on EVERY local free. Hoisting the call out of +the CAS loop did not help; a may-return cold callee in tail position is a +`je` straight to it, and does. + +**Tests.** `tests/double_free.rs` +4 child-process regressions (abandoned +page; `set_default_heap` then exit; first-class heap then exit; interleaved +A-B-A), green under default, `secure`, `blockmap`, both. `tests/openheimer.rs` +kept 37 of the campaign's 95 (every lie-input test went with its guard, and +one that asserted a `cfg!` constant went for being vacuous); +the FFI pack kept 8 of 16, two rewritten to null / misaligned inputs after +the 64 KiB out-pointer floor was dropped — it would have refused legitimate +out-pointers on wasm32, where static data starts at 1 KiB. Full suite green at +default and `ra_small_profile`; gate-selftest, wasm-size, unsafe census +(909 → 928, every site rowed in `UNSAFE.md`). + +**Not measured on hardware.** Instruction counts only; the icount farm +(`bench/icount-arms.sh`, scheduled) is where the mimalloc ratio gets re-read. + ## LARGE-ALLOCATION CEILING — a 64 KiB block cost two segments; a geometry knob takes 1 block to 3 (2026-09-09) `docs/plans/finished/esp32-large-alloc-ceiling.md`, reported from the diff --git a/docs/plans/openheimer-run.md b/docs/plans/openheimer-run.md new file mode 100644 index 0000000..ca58355 --- /dev/null +++ b/docs/plans/openheimer-run.md @@ -0,0 +1,206 @@ +# Openheimer run — rusty_alloc + +**Repo**: rusty_alloc (`f:/coding/rusty_alloc`) +**Class(es)**: alloc — the process heap. Untrusted inputs are sizes, alignments, counts, and pointers handed to `free`/`realloc`. +**Tier**: critical-path — every Remade crate that installs this as `#[global_allocator]` inherits its failure modes. +**Commit SHA**: `6a5efabd0af458fe89591e3dcce226be22aa6877` +**Date**: 2026-09-15 +**Operator**: Openheimer campaign (first Wave A unit — bottom of the supply chain) +**Last use-protection-please audit**: [docs/plans/use-protection-please.md](use-protection-please.md) (workspace) · crate: `crates/rusty_alloc/docs/plans/use-protection-please.md` +**Threat model**: [docs/threat-model.md](../threat-model.md) +**SECURITY.md**: yes +**Eligibility (§3.7)**: **internal-only** — H-27 soak completes 2026-09-19; no 14-day Openheimer recert yet; public bounty fragment not enabled. + +**Red log (hand-off):** [`f:/coding/openheimer/docs/results/rusty_alloc_openheimer_results.md`](../../../openheimer/docs/results/rusty_alloc_openheimer_results.md) — append-only; this run file does not replace it. + +**Disposition (2026-09-16, branch `openheimer-real`):** the campaign's working tree was SPLIT, not landed. §4 lists what landed (boundary validation: values a caller can choose, on cold paths or at zero local-path cost), what was withdrawn (guards on internal `unsafe fn` contracts that taxed the hot path — 139 of the 202 IDs), and the one fix the log claimed that had never been written (OH-11). Every number in §4 is from the release assembly, main against branch, Windows and Linux. + +Why this unit first: it sits under SpaceDB, Deputy, FFAI, remade_ffmpeg_rs, and every deliverable that pulls `rusty_alloc_default`. A panic, wrap, or silent double-free here is every product's bug. + +--- + +## 1. Surfaces + +| Surface | Where it lives | Untrusted input | Probe pack | Standing test / fuzz target | +|---|---|---|---|---| +| Library alloc API | `crates/rusty_alloc/src/alloc.rs` | size, count, align, `*mut u8` | alloc | `tests/openheimer.rs`; openheimer `probes/rusty_alloc/tests/hostile.rs`; `tests/alloc_core.rs`; `tests/properties.rs`; `fuzz/fuzz_targets/alloc_ops.rs` | +| Double-free / corruption | `page_push_local`, free-list | twice-freed / poisoned link | alloc | `tests/double_free.rs`; `tests/corruption.rs`; `fuzz/fuzz_targets/corruption.rs` | +| Cross-thread free | `xthread` protocol | remote `free` | alloc | `fuzz/fuzz_targets/xthread.rs`; loom (cited in threat model) | +| C ABI | `crates/rusty_alloc_ffi` | `mi_*` / malloc | alloc + bin | ffi crate tests; same core | +| `#[global_allocator]` | `rusty_alloc_api` / `_override` / `_default` | the host process | alloc | `rusty_alloc_bench/tests/selfhost.rs` | +| `secure` / `blockmap` / `linkcheck` | features, off by default | hostile in-process attacker | alloc | `tests/secure.rs`; `tests/corruption.rs` (needs `--features secure`) | +| no_std / chip | `prim::fixed`, `--cfg ra_single_threaded` | firmware region | alloc | compile_error without the cfg; Wave D overlap | +| Supply chain | `deny.toml`, lockfile | crates.io | posture | H-07–H-14 completed in UPP | + +--- + +## 2. Failure classes in play + +| F-ID | Applies? | Probe | +|---|---|---| +| F-01 panic on garbage | yes (abort on corruption is *policy*) | `double_free.rs` — abort, not continue | +| F-02 unbounded CPU | low | collect/heartbeat bounded; no regex | +| F-03 unbounded alloc | yes | OOM → null on malloc paths; R-003 heap-create OOM still aborts (accepted) | +| F-04 integer wrap | yes | `openheimer.rs` calloc/mallocn/recalloc overflow → null; `is_aligned_to` total | +| F-05 unsafe OOB | yes | `UNSAFE.md`; Miri in CI; SIMD N/A | +| F-06 forged success | n/a (no identity) | — | +| F-07 scope widening | n/a | — | +| F-08 replay / expiry | n/a | — | +| F-09 secret disclosure | residual | H-20 N/A (no user secrets); H-35 analysed; recycled blocks / zalloc | +| F-10 integrity / substitution | supply chain | deny + lockfile | +| F-11 differential lie | yes | mimalloc oracle / icount corpus (perf), not a security oracle | +| F-12 deser gadget | n/a | — | +| F-13 wasm blow-up | wasm prim | `rusty_alloc_wasm`; single-thread static TLS | +| F-14 supply-chain execute | no build.rs in core | deny policy | +| F-15 authz skip | n/a | — | + +--- + +## 3. Live jobs (evidence) + +| Cadence | Job / command | Last SHA | Result | Log URL | +|---|---|---|---|---| +| PR | `.github/workflows/ci.yml` (test, deny, audit, miri, fuzz smoke) | origin/main | assumed live; this run re-executes the Openheimer pack locally | | +| Nightly fuzz | `.github/workflows/fuzz.yml` — alloc_ops, xthread, corruption+secure; corpus cached | soak started 2026-08-19 | H-27 Scheduled until **2026-09-19**; ~7.0M execs cited, 0 crashers at last UPP | GitHub Actions `fuzz` | +| Miri / sanitizer | CI miri on api + properties; ASan on fuzz soak | cited in UPP H-23/H-26 | Completed for Miri tests that exist | | +| Differential corpus | mimalloc-bench / icount | perf, not fail-closed | N/A for Openheimer | | + +This run executed locally (2026-09-15): `cargo test -p rusty_alloc --test openheimer` in this repo, and `cargo test -p oh-rusty-alloc --test hostile` in `f:/coding/openheimer` (see audit log). + +--- + +## 4. Findings this run — as landed + +### 4.1 Landed (boundary validation) + +| IDs | Surface | Untrusted value | Fix | Regression | +|---|---|---|---|---| +| OH-1..4 | threat model | — | already accepted residuals / calendar (R-001, R-003, H-27) | `tests/foreign_free.rs`; threat model | +| OH-5 | `bins::is_aligned_to` | `align` | `is_aligned_to(x, 0)` was true for every `x`; now `align != 0 && align & (align-1) == 0 && x & (align-1) == 0` (spelled out: `is_power_of_two()` was a 20-instruction SWAR popcount without `popcnt`) | `oh_f04_is_aligned_to_is_total` | +| OH-6, 42..45 | `malloc_aligned_at`, `realloc_aligned_at`, `rezalloc_aligned_at`, `huge_alloc`, FFI twins | `offset`, `align` | `bins::aligned_at_from` / `is_aligned_at` checked; refuse with null and release the oversize block or huge reservation | `oh_f04_aligned_at_huge_offset_returns_null`, `oh_f04_realloc_inplace_huge_offset_is_null`, `oh_f04_rezalloc_*`, FFI `oh_f04_heap_realloc_*` | +| OH-7 | `debug_foreign_pointer_guard` | `p` | `assert!` — `debug_assert!` was compiled out of `--release --features debug_checks` | `--release --features debug_checks --test foreign_free` | +| OH-8 | `Heap::malloc_aligned_at` peek | `align == 0` | `align.wrapping_sub(1)` (identical release codegen; debug no longer panics before the slow path refuses) | `oh_f01_align_zero_on_warm_heap_returns_null` | +| OH-9, 10, 28, 29, 31 | `huge_alloc`, `os::page_align_up`, `os::alloc_aligned`, guarded alloc | `size`, `align` | checked adds / muls; garbage align is `Err(22)`; unrepresentable is `Err`/null | `oh_f01_huge_nonwrapping_size_returns_null`, `oh_f01_os_alloc_aligned_*`, `oh_f01_guarded_malloc_max_is_null`, `oh_f01_huge_alloc_bad_align_is_err` | +| OH-11 | `remote_free` (NEVER / NORMAL / DELAYED arms) | twice-freed block | **written this pass** (the log's fix did not exist): refuse a block that is already the chain head at push time; bound the collect walk by `used` so the interleaved cyclic chain aborts instead of hanging | `tests/double_free.rs` ×4, under default / `secure` / `blockmap` / both | +| OH-12, 22, 25, 27 | arena chunk API | `count`, `p` | `reserve_os_memory_ex` checked mul; `chunk_alloc_n(0)` is `None`; `chunk_free_n` bounds the bitmap; interior `chunk_free` is false | `oh_f04_arena_reserve_huge_is_err`, `oh_f04_chunk_alloc_n_zero_is_none`, `oh_f04_chunk_free_n_zero_and_huge_are_false`, `oh_f05_chunk_free_interior_is_false` | +| OH-13 | thread exit | — | `create_heap` bootstraps the thread's backing heap (and exit hook); exit abandons every heap the dying thread still owns, not only `done_slot` | `set_default_heap_abandoned_double_free_aborts`, `first_class_heap_abandoned_double_free_aborts` | +| OH-14, 16, 26 | FFI `mi_reserve_huge_os_pages*`, `mi_dupenv_s`, `mi_realpath` | `pages`, out-pointers, path | checked `pages * 1 GiB` (ENOMEM); EINVAL clears outs; `PATH_MAX` cap | FFI `oh_f04_reserve_huge_*`, `oh_f01_dupenv_*`, `oh_f05_realpath_*` | +| OH-15, 201, 202 | `manage_os_memory_ex` | `start`, `size` | non-null, non-wrapping, mapped (`prim::range_is_reserved`: `mincore` / `VirtualQuery`), not an already-registered window; `arena_register` CAS + free-on-refuse | `oh_f04_manage_os_memory_null_is_err`, `oh_f05_manage_os_memory_{garbage_base,unmapped,live_window}_is_err`, `oh_f05_manage_os_memory_real_block_still_works` | +| OH-17, 23, 24 | option hooks | hook re-entry | thread-local in-hook flags | `oh_f01_{deferred_free_hook_that_mallocs,error_hook_reentry,output_hook_reentry}_is_contained` | +| OH-18, 19, 20, 21 | `options::get_clamp` / `get_size`, `page_under_utilized`, `subproc_*` | option values, `perc`, `id` | swap inverted bounds; checked KiB; saturating percentage; exhaustion / out-of-range id refused instead of `assert!` | `oh_f01_option_get_clamp_inverted_is_total`, `oh_f04_option_get_size_huge_does_not_wrap`, `oh_f01_page_under_utilized_huge_perc_is_bool`, `oh_f01_subproc_add_oob_is_noop` | +| OH-30 | `segment_map::register_range` | `size` | `walk_windows` stops at unrepresentable addresses and on `checked_add` overflow; range/base tables use checked / saturating ends | reachable only through validated callers now; kept as defense in depth | +| OH-32, 33, 34 | `bin_size`, `prim::fixed::dedicated_segments` / `region_for` | index, `size` | checked; garbage is 0 / unrepresentable | `oh_f04_bin_size_garbage_index_is_total`, `oh_f04_dedicated_segments_max_is_unrepresentable`, `oh_f04_region_for_max_is_zero` | +| OH-38, 60 | `prim::alloc`, `prim::commit` | `align`, null | `Err` before the syscall (commit(null) handed Windows an untracked mapping) | `oh_f01_prim_alloc_bad_align_is_err`, `oh_f01_prim_commit_null_is_err` | +| OH-54, 58, 97..102 | FFI heap handles and out-pointers | `heap`, `out` | `heap_ptr`: null / misaligned / immortal-empty is "no heap"; `mi_heap_set_default` refuses such a handle; `out_mut`: null / misaligned out-pointers are never written (the 64 KiB floor is gone — it would refuse legitimate wasm32 out-pointers) | FFI `oh_f01_heap_visit_blocks_null_is_total`, `oh_f01_ffi_out_param_null_or_misaligned_is_refused`, `oh_f01_ffi_cstr_null_is_refused` | +| OH-62, 65, 66 | `malloc_small` / `zalloc_small`, FFI `mi_free_size` / `mi_free_aligned` | `size` | forward / ignore instead of `debug_assert!` on a public entry | `oh_f01_malloc_small_max_is_null` | + +### 4.2 Withdrawn (internal-contract guards) + +**OH-35, 36, 37, 40, 41, 46–53, 55–57, 59, 61, 63, 64, 67–200** — 139 IDs, +one probe: an internal `unsafe fn` (`page_of`, `page_index`, `page_area`, +`span_alloc`, `span_free`, `segment_free`, `huge_free`, `purge_free_spans`, +`visit_segment_blocks`, `adopt_segment`, `free_local`, `free_local_at`, +`retire_emptied`, `box_of_xheap`, `ensure_heap`, `heap_of`, `thread_done`, +`heap_delete`, `heap_destroy`, `set_default_heap`, `page_link_local`, +`page_extend`, `block_next`, `remote_free`, `segment_map::register`) handed +null, `0x1`, or `floor + 8`, chased up a ladder of floors (`0x1000`, +`0x10000`, `SEGMENT_SIZE`, 2×, 3×, 4×) and answered with a segment-map +membership lookup on every internal handle (`aligned_mut`) plus a heap +registry walk under a global lock (`live_heap_box`). + +Why withdrawn: + +1. **They guard contracts the caller inside this crate upholds.** Every one of + those functions is `unsafe fn` with a stated contract, called only from + this crate with values it derived itself. A guard there is not boundary + validation; it is a second copy of the caller's invariant, and R-001 + already accepts that release `free` trusts its pointer's window. +2. **They taxed the hot path, and the campaign never measured it.** At its + stopping point, release assembly against 2.2.0: `free` **+27**, `realloc` + **+164**, `page_extend` **+68** instructions; `box_of_xheap` walked the + heap registry under a global lock on the free path. The log mentions + instruction counts three times and never once acknowledges these. +3. **The membership gate was circular.** `segment_map::register` was gated + on `contains(seg)` — a fresh segment cannot be in the map yet — so a + second `register_fresh` bypassed it; `heap_ptr` at the C ABI used the + segment map to validate a HeapBox that lives on its own OS page and is + only in the map by accident of address-space layout. The test that + "proved" `register_range(0, MAX)` safe passed only because the gate made + it a no-op; against the real function it paints every window in the map. +4. **The regressions did not pass.** Three of the log's High-severity tests + failed on its own branch (exit 97: the second free RETURNED) because the + OH-11 fix they depended on was never written. + +What replaced them: nothing on the internal seams; the same inputs are +refused where they enter — `manage_os_memory`, the C ABI, the option table, +the OS wrappers — and the double-free arm that was actually missing (§4.1, +OH-11). + +### 4.3 Cost, as landed + +x86-64 release, main → branch, Windows / Linux: `free` 62 → 66 / 63 → 67 +(two `cmp; je` on the cross-thread arm; the local path is byte-identical and +the function keeps no frame — see `page::remote_double_free` for the three +tries that took); `malloc` 0 / 0; `malloc_aligned_at` 0 / 0; `realloc` +7 / ++6; `realloc_aligned_at` +1 / +1; `page_extend` 0 / 0; `usable_size` 0 / 0; +`remote_free` +4 / +4; `huge_alloc` +29 / −14 (cold). Unsafe census 909 → +928, every site rowed in `crates/rusty_alloc/UNSAFE.md`. + +--- + +## 5. Eligibility recert + +- [x] H-01 threat model linked from README +- [x] H-39 SECURITY.md with contact + window +- [x] Every parser/identity/net/store/ai surface has a fuzz or property target — **alloc surfaces do** (`alloc_ops`, `xthread`, `corruption`) +- [ ] Farm ≥ 7 consecutive green days (30 before raising payouts) — soak in progress, completes 2026-09-19 +- [x] H-18: no unwrap on inventoried untrusted paths (UPP Completed) +- [x] This file dated within 14 days +- [ ] Named bounty budget (if claiming public) + +**Verdict**: **internal-only** + +Do not paste `templates/SECURITY-bounty.md` into this repo yet. + +--- + +## Audit log + +| Date | SHA | What changed | +|---|---|---| +| 2026-09-15 | 6a5efab | First Openheimer run. Added `tests/openheimer.rs`. **OH-rusty_alloc-5 found and fixed:** `is_aligned_to(x, 0)` was universally true. | +| 2026-09-15 | 6a5efab | Campaign hostile pack lives in openheimer (`probes/rusty_alloc/tests/hostile.rs`). | +| 2026-09-15 | 6a5efab | **OH-rusty_alloc-6 found and fixed:** `malloc_aligned_at` panicked (debug) / would wrap (release) on `offset = usize::MAX`. Checked placement in `bins::aligned_at_from`; oversize block and huge reservation are released on refuse. | +| 2026-09-15 | 6a5efab | **OH-12…16 found and fixed (uncommitted):** arena reserve mul; first-class heaps not abandoned on thread exit; huge-OS-page `pages*1GiB`; `manage_os_memory` null/overflow; `dupenv` EINVAL outs. See openheimer red log. | +| 2026-09-15 | 6a5efab | **OH-17…22 found and fixed (uncommitted):** deferred-free re-entry stack overflow; `get_clamp` inverted; `get_size` KiB wrap; under-utilized perc overflow; subproc id assert; `chunk_alloc_n(0)`. | +| 2026-09-15 | 6a5efab | **OH-23…26 found and fixed (uncommitted):** error/output hook re-entry stack overflow; `chunk_free_n` bitmap OOB; `mi_realpath` PATH_MAX cap. | +| 2026-09-15 | 6a5efab | **OH-27…28 found and fixed (uncommitted):** interior `chunk_free` released a live chunk; `os::alloc_aligned` panicked on garbage align. | +| 2026-09-15 | 6a5efab | **OH-29 found and fixed (uncommitted):** `os::alloc_aligned(MAX)` overflowed `size + alignment` in the prim aligned-reserve dance. | +| 2026-09-15 | 6a5efab | House audit (OH-2 evidence, no new id): `mata-alloc` has no `blockmap` feature; named disco/console binaries ship without `secure`. `region.rs` 1/1 under `ra_small_profile`+`ra_single_threaded`. Arena register CAS + `arena_area` cap. A3: `cargo deny`/`audit` ok; `cargo vet` red on unvetted `portable-atomic 1.15.0`. | +| 2026-09-15 | 6a5efab | **OH-30 found and fixed (uncommitted):** `segment_map::register_range(0, MAX)` hung (release infinite loop / debug overflow). `walk_windows` stops at unrepresentable addresses. | +| 2026-09-15 | 6a5efab | **OH-31 / OH-32 found and fixed (uncommitted):** guarded `malloc(MAX)` overflowed `payload + page`; public `bin_size(MAX)` overflowed `bin + 3`. | +| 2026-09-15 | 6a5efab | **OH-33…37 found and fixed (uncommitted):** `dedicated_segments(MAX)` wrap-to-1; `region_for(MAX)` mul; `page_off_for(MAX)` mul; `span_alloc(MAX)` unbounded mark; `span_alloc(0)` zero-length span. | +| 2026-09-15 | 6a5efab | **OH-38…47 found and fixed (uncommitted):** `prim::alloc` / `huge_alloc` garbage align; `page_area` / `page_of` / `page_index`; in-place realloc `addr+offset` (Rust + extern-C abort); `box_of_xheap(0)`. | +| 2026-09-15 | 6a5efab | **OH-48…57 found and fixed (uncommitted):** empty/`null` heap delete; `heap_malloc(null)`; `huge_free` of Normal; `page_index(null)`; `segment_free` in-use; `set_default_heap(null)`; `span_alloc(null)`; `span_free` uncarved OOB; `thread_done(null)`. | +| 2026-09-15 | 6a5efab | **OH-58…61 found and fixed (uncommitted):** FFI `mi_heap_visit_blocks(null)` abort; public page helpers of null; `prim::commit(null)` allocated an untracked Windows mapping; `visit_segment_blocks(null)` abort. | +| 2026-09-15 | 6a5efab | **OH-62…63 found and fixed (uncommitted):** `malloc_small(MAX)` debug_assert; `page_link_local(null)` abort. | +| 2026-09-15 | 6a5efab | **OH-64…67 found and fixed (uncommitted):** `page_extend(live, null)` AV; FFI `mi_free_size`/`mi_free_aligned` debug_assert abort; `segment_map::register(null)` marked window 0. | +| 2026-09-15 | 6a5efab | **OH-68…69 found and fixed (uncommitted):** `remote_free(DELAYED page, null)` abort; `page_extend(live, lying area)` walked foreign memory. | +| 2026-09-15 | 6a5efab | **OH-70…74 found and fixed (uncommitted):** lying `0x1` handles — `page_index`, segment free/visit/purge, free-list writers, `heap_malloc`, `set_default_heap`. | +| 2026-09-15 | 6a5efab | **OH-75…80 found and fixed (uncommitted):** remaining `0x1` siblings — page helpers, heap teardown, FFI `heap_ptr`, `span_alloc`, close-range `page_of`, `page_area` forwarded lie. | +| 2026-09-15 | 6a5efab | **OH-81…85 found and fixed (uncommitted):** `page_extend(0x1, live area)`; `block_next(0x1)`; `usable_size(0x1)` null-page deref; FFI under-utilized of `0x1`; `ensure_heap(0x1)` forwarded lie. | +| 2026-09-15 | 6a5efab | **OH-86…91 found and fixed (uncommitted):** `realloc`/`heap_realloc`/`reallocf` of `0x1` called `free` on the lie; `free_local(0x1)` AV; `adopt_segment(0x1)` abort; `box_of_xheap(1)` forwarded lie. | +| 2026-09-15 | 6a5efab | **OH-92…94 found and fixed (uncommitted):** aligned first-page lie `0x8` passed `aligned_mut`; `retire_emptied(0x1)`; `free_local_at(0x1)`. | +| 2026-09-15 | 6a5efab | **OH-95…102 found and fixed (uncommitted):** `register(0x8)` / `register_range(8)` painted window 0; FFI first-page out-params (`posix_memalign` / `reallocarr` / `umalloc` / `arena_area` / `process_info` / `reserve_huge_os_pages`). | +| 2026-09-15 | 6a5efab | **OH-103…115 found and fixed (uncommitted):** `MIN_OBJECT_ADDR` 4096 let `0x1000` through; C-string / path / env name of `0x8`; `manage_os_memory_ex(0x8, 2*SEGMENT)` registered a fake arena. | +| 2026-09-15 | 6a5efab | **OH-116…130 found and fixed (uncommitted):** `0x10000` sat on the exclusive 64 KiB floor — typed-metadata AV, window-0 paint, fake arena, forwarded `ensure_heap`. `MIN_META_ADDR = SEGMENT_SIZE`; C-string / out-params stay at 64 KiB. | +| 2026-09-15 | 6a5efab | **OH-131…150 found and fixed (uncommitted):** `SEGMENT_SIZE` sat on the exclusive metadata floor — typed-metadata AV, window-1 paint, fake arena, forwarded `ensure_heap` / `box_of_xheap` / `page_area`. Floor is now inclusive (`addr <= MIN_META_ADDR`). | +| 2026-09-15 | 6a5efab | **OH-151…165 found and fixed (uncommitted):** `SEGMENT_SIZE+8` / `+1` sat on the inclusive 32 MiB floor — typed-metadata AV, window-1 paint, fake arena at `2*SEGMENT`, forwarded lies, `span_free`. `MIN_META_ADDR` is now `2 * SEGMENT_SIZE`. | +| 2026-09-15 | 6a5efab | **OH-166…180 found and fixed (uncommitted):** `2*SEGMENT+8` / `+1` sat on the two-window floor — typed-metadata AV, window-2 paint, fake arena at `3*SEGMENT`, forwarded lies, `span_free`. `MIN_META_ADDR` is now `3 * SEGMENT_SIZE`. | +| 2026-09-15 | 6a5efab | **OH-181…200 found and fixed (uncommitted):** `3*SEGMENT+8` / `+1` sat on the three-window floor — typed-metadata AV, window-3 paint, fake arena at `4*SEGMENT`, forwarded lies, `span_free`, `heap_destroy` / `thread_done` / `heap_zalloc` / `span_alloc` / `huge_free`. `MIN_META_ADDR` is now `4 * SEGMENT_SIZE`. | +| 2026-09-15 | 6a5efab | **Floor class closed (uncommitted):** `aligned_mut` is membership (`segment_map::contains`); HeapBox uses the live-heap registry; public `register`/`register_range` cannot paint a new window. `MIN_META_ADDR` is an alias of `MIN_OBJECT_ADDR` (64 KiB), not a rising window floor. Removed hew/rasp/whet packs and the per-window product copies. Standing regression: `oh_f01_meta_lie_unregistered_is_total`. | +| 2026-09-15 | 6a5efab | **OH-201…202 found and fixed (uncommitted):** `manage_os_memory_ex(1TiB)` registered a fake arena (next default malloc AVs); `manage(live segment)` adopted a named window. Refuse unless `os::range_is_reserved` and `!segment_map::contains(lo)`. Real OS blocks and same-block `MAX_ARENAS` fill (`chase.rs`) still work. | +| 2026-09-16 | `openheimer-real` | **Disposition.** The uncommitted tree was split: §4.1 landed, §4.2 withdrawn (139 IDs: internal-contract guards, `free` +27 / `realloc` +164 / `page_extend` +68 at the campaign's stopping point). `page.rs` reverted whole (its only changes were `aligned_mut` guards on internal machinery). | +| 2026-09-16 | `openheimer-real` | **OH-11 written** — the log's fix did not exist (`git diff \| grep -c xthread_free` = 0) and its three tests failed. `remote_free` head check at push time; collect walk bounded by `used` (the chain a remote double free leaves is CYCLIC; the pre-existing `n > used` check sat after the walk and could not be reached). Fourth regression: interleaved A-B-A. | +| 2026-09-16 | `openheimer-real` | `tests/openheimer.rs` 95 → 37 (every lie-input test went with its guard; `oh_f02_segment_map_huge_range_is_total` went because against the real `register_range` it paints the whole map; `oh_f05_secure_feature_is_not_vacuous` went because it asserted a `cfg!` constant — the vacuous test); FFI pack 16 → 8, two rewritten to null / misaligned inputs after the 64 KiB out-pointer floor was dropped (wasm32 static data starts at 1 KiB). | +| 2026-09-16 | `openheimer-real` | `bins::is_aligned_to`: `is_power_of_two()` emitted as a 20-instruction SWAR popcount without `popcnt` (`realloc_aligned_at` +43); spelled as `align & (align - 1)` (+1). | diff --git a/docs/threat-model.md b/docs/threat-model.md index 184e07e..75ce412 100644 --- a/docs/threat-model.md +++ b/docs/threat-model.md @@ -56,7 +56,7 @@ least every 12 months (next: 2027-08-19 or earlier per the audit cadence in | Threat | Instance here | Mitigation / status | |---|---|---| | **S**poofing | A recycled thread id impersonating a dead owner | Dying threads abandon segments (id → 0) before the TCB can be recycled; TLS storage is the thread's own block (`.tdata` image), so a recycled TCB cannot inherit a live heap pointer | -| **T**ampering | T1: `free()` on a forged/foreign pointer — `page_of` trusts `slice_offset` read from the pointer's own 32 MiB window (upstream mimalloc parity) | Partial: `secure` feature encrypts free-list links (corruption detected on decode) and adds guard pages; double frees abort on both local and remote paths; full pointer validation (segment-map membership on the free path) is a residual risk — R-001, and the reason `secure` exists for hostile-input services | +| **T**ampering | T1: `free()` on a forged/foreign pointer — `page_of` trusts `slice_offset` read from the pointer's own 32 MiB window (upstream mimalloc parity) | Partial: `secure` feature encrypts free-list links (corruption detected on decode) and adds guard pages; double frees abort on both local and remote paths — the remote arm refuses a block that is already the `xthread_free` head at push time, and the owner's collect walk is bounded by `used`, so an interleaved remote double free (whose chain is cyclic) aborts on the first collect instead of hanging; until 2026-09-16 the remote check sat AFTER that walk and was unreachable for exactly that input (OH-rusty_alloc-11); full pointer validation (segment-map membership on the free path) is a residual risk — R-001, and the reason `secure` exists for hostile-input services | | | T2: free-list poisoning via a caller write primitive — the classic heap-exploitation move, where an overwritten link makes the next allocation return an attacker-chosen address and every write through it an arbitrary write | `secure`: per-page keyed link encoding, plus a decode check requiring the link to be block-aligned AND inside the SAME segment as the block carrying it (`page::link_is_plausible`), aborting silently rather than following it. The segment bound is what constrains a DELIBERATE attacker — alignment alone filters accidents, since every address worth steering an allocator at is already pointer-aligned. Both arms are adversarially tested (`tests/corruption.rs` poisons a real free list and asserts SIGABRT, not SIGSEGV) and fuzzed (`fuzz_targets/corruption.rs`). **The default build performs neither the encoding nor the check** — upstream parity, and the reason enabling `secure` is a security decision rather than a performance one | | **R**epudiation | (not applicable — no authentication or audit domain of its own) | N/A | | **I**nformation disclosure | Recycled blocks leaking prior contents through the zero guarantee | `free_is_zero` is conservatively cleared on purge/reuse; the zalloc invariant is G1-gated on 1M-op traces; the Darwin decommit contract violation that could have stale-exposed pages was found and fixed in 0.4.0 | diff --git a/fuzz/corpus/alloc_ops/001bf513ccc6f031bc8a644171d6526922c46d67 b/fuzz/corpus/alloc_ops/001bf513ccc6f031bc8a644171d6526922c46d67 new file mode 100644 index 0000000..39dca5f Binary files /dev/null and b/fuzz/corpus/alloc_ops/001bf513ccc6f031bc8a644171d6526922c46d67 differ diff --git a/fuzz/corpus/alloc_ops/002a423047b2e31e45e6fc4a8fef184e8dcd0a1a b/fuzz/corpus/alloc_ops/002a423047b2e31e45e6fc4a8fef184e8dcd0a1a new file mode 100644 index 0000000..6e63661 Binary files /dev/null and b/fuzz/corpus/alloc_ops/002a423047b2e31e45e6fc4a8fef184e8dcd0a1a differ diff --git a/fuzz/corpus/alloc_ops/0051f6db522280a3a346dabf3430c8e9d7d14a7f b/fuzz/corpus/alloc_ops/0051f6db522280a3a346dabf3430c8e9d7d14a7f new file mode 100644 index 0000000..6774f03 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0051f6db522280a3a346dabf3430c8e9d7d14a7f differ diff --git a/fuzz/corpus/alloc_ops/0054d9c6222e49ab62fca92644d97d08b84be016 b/fuzz/corpus/alloc_ops/0054d9c6222e49ab62fca92644d97d08b84be016 new file mode 100644 index 0000000..7ebcf5c Binary files /dev/null and b/fuzz/corpus/alloc_ops/0054d9c6222e49ab62fca92644d97d08b84be016 differ diff --git a/fuzz/corpus/alloc_ops/00567cc818248e2cbebc9b9a0def74c2171cde59 b/fuzz/corpus/alloc_ops/00567cc818248e2cbebc9b9a0def74c2171cde59 new file mode 100644 index 0000000..cdeda96 Binary files /dev/null and b/fuzz/corpus/alloc_ops/00567cc818248e2cbebc9b9a0def74c2171cde59 differ diff --git a/fuzz/corpus/alloc_ops/00be8376d763b3f0de6a572ff06bc0443e42b678 b/fuzz/corpus/alloc_ops/00be8376d763b3f0de6a572ff06bc0443e42b678 new file mode 100644 index 0000000..0062f24 --- /dev/null +++ b/fuzz/corpus/alloc_ops/00be8376d763b3f0de6a572ff06bc0443e42b678 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/00ce74828bc2f45a8191e93f0c8afd4252ec9313 b/fuzz/corpus/alloc_ops/00ce74828bc2f45a8191e93f0c8afd4252ec9313 new file mode 100644 index 0000000..0471617 Binary files /dev/null and b/fuzz/corpus/alloc_ops/00ce74828bc2f45a8191e93f0c8afd4252ec9313 differ diff --git a/fuzz/corpus/alloc_ops/015051d32e1f5b158e8e1ab848eadfc767f74ac1 b/fuzz/corpus/alloc_ops/015051d32e1f5b158e8e1ab848eadfc767f74ac1 new file mode 100644 index 0000000..ab745c5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/015051d32e1f5b158e8e1ab848eadfc767f74ac1 differ diff --git a/fuzz/corpus/alloc_ops/0168419e2355c1529d377612fcc8c8adc9ffaf99 b/fuzz/corpus/alloc_ops/0168419e2355c1529d377612fcc8c8adc9ffaf99 new file mode 100644 index 0000000..0751c9b Binary files /dev/null and b/fuzz/corpus/alloc_ops/0168419e2355c1529d377612fcc8c8adc9ffaf99 differ diff --git a/fuzz/corpus/alloc_ops/017ed2a7bf71a64e14ffe5dc2a71ea707fb8e15e b/fuzz/corpus/alloc_ops/017ed2a7bf71a64e14ffe5dc2a71ea707fb8e15e new file mode 100644 index 0000000..0a6fe97 Binary files /dev/null and b/fuzz/corpus/alloc_ops/017ed2a7bf71a64e14ffe5dc2a71ea707fb8e15e differ diff --git a/fuzz/corpus/alloc_ops/01872f1b1a853387261b54284185722167b1046b b/fuzz/corpus/alloc_ops/01872f1b1a853387261b54284185722167b1046b new file mode 100644 index 0000000..9a18b0c Binary files /dev/null and b/fuzz/corpus/alloc_ops/01872f1b1a853387261b54284185722167b1046b differ diff --git a/fuzz/corpus/alloc_ops/01aed48a816d045e75fcf5be0bfdd2e583572c8d b/fuzz/corpus/alloc_ops/01aed48a816d045e75fcf5be0bfdd2e583572c8d new file mode 100644 index 0000000..9bcc821 Binary files /dev/null and b/fuzz/corpus/alloc_ops/01aed48a816d045e75fcf5be0bfdd2e583572c8d differ diff --git a/fuzz/corpus/alloc_ops/01fc21c57440a2dee6f540aa4492fc24c345df70 b/fuzz/corpus/alloc_ops/01fc21c57440a2dee6f540aa4492fc24c345df70 new file mode 100644 index 0000000..a8e0bae Binary files /dev/null and b/fuzz/corpus/alloc_ops/01fc21c57440a2dee6f540aa4492fc24c345df70 differ diff --git a/fuzz/corpus/alloc_ops/01fe4b3b12b17af389a6d2db9f3a4230838a5264 b/fuzz/corpus/alloc_ops/01fe4b3b12b17af389a6d2db9f3a4230838a5264 new file mode 100644 index 0000000..8d2b96e Binary files /dev/null and b/fuzz/corpus/alloc_ops/01fe4b3b12b17af389a6d2db9f3a4230838a5264 differ diff --git a/fuzz/corpus/alloc_ops/022b37cd34c20226be533e2adf2a0faed73ec76a b/fuzz/corpus/alloc_ops/022b37cd34c20226be533e2adf2a0faed73ec76a new file mode 100644 index 0000000..825c4c6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/022b37cd34c20226be533e2adf2a0faed73ec76a differ diff --git a/fuzz/corpus/alloc_ops/022f21d8c0c1d3fe3356321867c28b97e9c7a800 b/fuzz/corpus/alloc_ops/022f21d8c0c1d3fe3356321867c28b97e9c7a800 new file mode 100644 index 0000000..7bef822 Binary files /dev/null and b/fuzz/corpus/alloc_ops/022f21d8c0c1d3fe3356321867c28b97e9c7a800 differ diff --git a/fuzz/corpus/alloc_ops/022f3b32c81b0a55a24ee8b997dea8178188f64d b/fuzz/corpus/alloc_ops/022f3b32c81b0a55a24ee8b997dea8178188f64d new file mode 100644 index 0000000..87f0206 Binary files /dev/null and b/fuzz/corpus/alloc_ops/022f3b32c81b0a55a24ee8b997dea8178188f64d differ diff --git a/fuzz/corpus/alloc_ops/023551c11e7b2f4b6553fa9d66173e4e0294781c b/fuzz/corpus/alloc_ops/023551c11e7b2f4b6553fa9d66173e4e0294781c new file mode 100644 index 0000000..3c2b4d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/023551c11e7b2f4b6553fa9d66173e4e0294781c differ diff --git a/fuzz/corpus/alloc_ops/0260446b3e379e2114791a3950e4c2dcc8cbcb0e b/fuzz/corpus/alloc_ops/0260446b3e379e2114791a3950e4c2dcc8cbcb0e new file mode 100644 index 0000000..382ba99 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0260446b3e379e2114791a3950e4c2dcc8cbcb0e differ diff --git a/fuzz/corpus/alloc_ops/028716c936d7a9a8463b019e503b6b1efc90f18d b/fuzz/corpus/alloc_ops/028716c936d7a9a8463b019e503b6b1efc90f18d new file mode 100644 index 0000000..ec99de7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/028716c936d7a9a8463b019e503b6b1efc90f18d differ diff --git a/fuzz/corpus/alloc_ops/031246f9f1ff3f40bc465a9517c6c562856b488e b/fuzz/corpus/alloc_ops/031246f9f1ff3f40bc465a9517c6c562856b488e new file mode 100644 index 0000000..77f6e1b Binary files /dev/null and b/fuzz/corpus/alloc_ops/031246f9f1ff3f40bc465a9517c6c562856b488e differ diff --git a/fuzz/corpus/alloc_ops/03362a4066e0df30ab63fdd6cbb2e155056d402c b/fuzz/corpus/alloc_ops/03362a4066e0df30ab63fdd6cbb2e155056d402c new file mode 100644 index 0000000..91f2223 Binary files /dev/null and b/fuzz/corpus/alloc_ops/03362a4066e0df30ab63fdd6cbb2e155056d402c differ diff --git a/fuzz/corpus/alloc_ops/034050b026a33bcf084c77fbadcc89fdbeaf1210 b/fuzz/corpus/alloc_ops/034050b026a33bcf084c77fbadcc89fdbeaf1210 new file mode 100644 index 0000000..63bc86b Binary files /dev/null and b/fuzz/corpus/alloc_ops/034050b026a33bcf084c77fbadcc89fdbeaf1210 differ diff --git a/fuzz/corpus/alloc_ops/0386f3dc42b5c8cdcd72d3514caa61764d1824f2 b/fuzz/corpus/alloc_ops/0386f3dc42b5c8cdcd72d3514caa61764d1824f2 new file mode 100644 index 0000000..c357379 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0386f3dc42b5c8cdcd72d3514caa61764d1824f2 differ diff --git a/fuzz/corpus/alloc_ops/04179d5d7dc831f5c7fd5be84c8195448c3a83bd b/fuzz/corpus/alloc_ops/04179d5d7dc831f5c7fd5be84c8195448c3a83bd new file mode 100644 index 0000000..957c867 Binary files /dev/null and b/fuzz/corpus/alloc_ops/04179d5d7dc831f5c7fd5be84c8195448c3a83bd differ diff --git a/fuzz/corpus/alloc_ops/041ca49007a0395544143f7e17b2f7caa34e02b7 b/fuzz/corpus/alloc_ops/041ca49007a0395544143f7e17b2f7caa34e02b7 new file mode 100644 index 0000000..91d8891 Binary files /dev/null and b/fuzz/corpus/alloc_ops/041ca49007a0395544143f7e17b2f7caa34e02b7 differ diff --git a/fuzz/corpus/alloc_ops/041e7adfbb4869299773007907004db7ac8ca30c b/fuzz/corpus/alloc_ops/041e7adfbb4869299773007907004db7ac8ca30c new file mode 100644 index 0000000..a962b99 Binary files /dev/null and b/fuzz/corpus/alloc_ops/041e7adfbb4869299773007907004db7ac8ca30c differ diff --git a/fuzz/corpus/alloc_ops/0435b6770f4268d315d010c832fe17f792b23763 b/fuzz/corpus/alloc_ops/0435b6770f4268d315d010c832fe17f792b23763 new file mode 100644 index 0000000..0a86c12 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0435b6770f4268d315d010c832fe17f792b23763 differ diff --git a/fuzz/corpus/alloc_ops/047f88eb595484682b460b3fc17d4b8838286484 b/fuzz/corpus/alloc_ops/047f88eb595484682b460b3fc17d4b8838286484 new file mode 100644 index 0000000..d45031d Binary files /dev/null and b/fuzz/corpus/alloc_ops/047f88eb595484682b460b3fc17d4b8838286484 differ diff --git a/fuzz/corpus/alloc_ops/049b7bddf65d29d7ef3fdf8afc173091955629d2 b/fuzz/corpus/alloc_ops/049b7bddf65d29d7ef3fdf8afc173091955629d2 new file mode 100644 index 0000000..de78ddc Binary files /dev/null and b/fuzz/corpus/alloc_ops/049b7bddf65d29d7ef3fdf8afc173091955629d2 differ diff --git a/fuzz/corpus/alloc_ops/04af66586f74a451f0f882b4e982894d7db97312 b/fuzz/corpus/alloc_ops/04af66586f74a451f0f882b4e982894d7db97312 new file mode 100644 index 0000000..c13612e Binary files /dev/null and b/fuzz/corpus/alloc_ops/04af66586f74a451f0f882b4e982894d7db97312 differ diff --git a/fuzz/corpus/alloc_ops/04d1dd30de56c5e4486ee201f79243a92523fa36 b/fuzz/corpus/alloc_ops/04d1dd30de56c5e4486ee201f79243a92523fa36 new file mode 100644 index 0000000..1063121 Binary files /dev/null and b/fuzz/corpus/alloc_ops/04d1dd30de56c5e4486ee201f79243a92523fa36 differ diff --git a/fuzz/corpus/alloc_ops/04dd121369c9d72dac67b5bb723edf709a5d1385 b/fuzz/corpus/alloc_ops/04dd121369c9d72dac67b5bb723edf709a5d1385 new file mode 100644 index 0000000..2436336 Binary files /dev/null and b/fuzz/corpus/alloc_ops/04dd121369c9d72dac67b5bb723edf709a5d1385 differ diff --git a/fuzz/corpus/alloc_ops/0561b9552ad56a7f69e4456e730296fe6ae3d16f b/fuzz/corpus/alloc_ops/0561b9552ad56a7f69e4456e730296fe6ae3d16f new file mode 100644 index 0000000..ac09a0b Binary files /dev/null and b/fuzz/corpus/alloc_ops/0561b9552ad56a7f69e4456e730296fe6ae3d16f differ diff --git a/fuzz/corpus/alloc_ops/0575af50c7804dc2fc91f133a1de457f721a2783 b/fuzz/corpus/alloc_ops/0575af50c7804dc2fc91f133a1de457f721a2783 new file mode 100644 index 0000000..252ea5a Binary files /dev/null and b/fuzz/corpus/alloc_ops/0575af50c7804dc2fc91f133a1de457f721a2783 differ diff --git a/fuzz/corpus/alloc_ops/057dbdc69b09d8fab56f80a323ef410769e9e613 b/fuzz/corpus/alloc_ops/057dbdc69b09d8fab56f80a323ef410769e9e613 new file mode 100644 index 0000000..5b9a69c Binary files /dev/null and b/fuzz/corpus/alloc_ops/057dbdc69b09d8fab56f80a323ef410769e9e613 differ diff --git a/fuzz/corpus/alloc_ops/059f65910f5aec7ef0474b85d056309bb13b9bcc b/fuzz/corpus/alloc_ops/059f65910f5aec7ef0474b85d056309bb13b9bcc new file mode 100644 index 0000000..d8d547f Binary files /dev/null and b/fuzz/corpus/alloc_ops/059f65910f5aec7ef0474b85d056309bb13b9bcc differ diff --git a/fuzz/corpus/alloc_ops/05c70ff2153b66b0fa67e055aeba7e7f9388a5a2 b/fuzz/corpus/alloc_ops/05c70ff2153b66b0fa67e055aeba7e7f9388a5a2 new file mode 100644 index 0000000..f318d4a Binary files /dev/null and b/fuzz/corpus/alloc_ops/05c70ff2153b66b0fa67e055aeba7e7f9388a5a2 differ diff --git a/fuzz/corpus/alloc_ops/063847bfbb6d2349b492d7b38b3eac2a60365ddf b/fuzz/corpus/alloc_ops/063847bfbb6d2349b492d7b38b3eac2a60365ddf new file mode 100644 index 0000000..1de0ccf Binary files /dev/null and b/fuzz/corpus/alloc_ops/063847bfbb6d2349b492d7b38b3eac2a60365ddf differ diff --git a/fuzz/corpus/alloc_ops/063e7d10e365f050cfc03b164490fb843446c820 b/fuzz/corpus/alloc_ops/063e7d10e365f050cfc03b164490fb843446c820 new file mode 100644 index 0000000..a43d9b4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/063e7d10e365f050cfc03b164490fb843446c820 differ diff --git a/fuzz/corpus/alloc_ops/06752e3ae3e6f7255992be1207fa7d7986108220 b/fuzz/corpus/alloc_ops/06752e3ae3e6f7255992be1207fa7d7986108220 new file mode 100644 index 0000000..0691ab6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/06752e3ae3e6f7255992be1207fa7d7986108220 differ diff --git a/fuzz/corpus/alloc_ops/06ab02084af46b1a0882c23cc6f671503cbb01c0 b/fuzz/corpus/alloc_ops/06ab02084af46b1a0882c23cc6f671503cbb01c0 new file mode 100644 index 0000000..f31165e Binary files /dev/null and b/fuzz/corpus/alloc_ops/06ab02084af46b1a0882c23cc6f671503cbb01c0 differ diff --git a/fuzz/corpus/alloc_ops/06e68a93507dfe7f0793b522cd100b52c7df078e b/fuzz/corpus/alloc_ops/06e68a93507dfe7f0793b522cd100b52c7df078e new file mode 100644 index 0000000..4686e66 Binary files /dev/null and b/fuzz/corpus/alloc_ops/06e68a93507dfe7f0793b522cd100b52c7df078e differ diff --git a/fuzz/corpus/alloc_ops/06edb02cddfeac3a72d1284cb83ff551deeac75a b/fuzz/corpus/alloc_ops/06edb02cddfeac3a72d1284cb83ff551deeac75a new file mode 100644 index 0000000..a57a2ea Binary files /dev/null and b/fuzz/corpus/alloc_ops/06edb02cddfeac3a72d1284cb83ff551deeac75a differ diff --git a/fuzz/corpus/alloc_ops/06f9cc19f865d8242798cae4bbc7e93aceff14c6 b/fuzz/corpus/alloc_ops/06f9cc19f865d8242798cae4bbc7e93aceff14c6 new file mode 100644 index 0000000..2607e8e Binary files /dev/null and b/fuzz/corpus/alloc_ops/06f9cc19f865d8242798cae4bbc7e93aceff14c6 differ diff --git a/fuzz/corpus/alloc_ops/070acf31d211c0550bd217a8634f6740432439c6 b/fuzz/corpus/alloc_ops/070acf31d211c0550bd217a8634f6740432439c6 new file mode 100644 index 0000000..6ca07c2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/070acf31d211c0550bd217a8634f6740432439c6 differ diff --git a/fuzz/corpus/alloc_ops/07589b60d038dac2582a99ccead4a4c397c50687 b/fuzz/corpus/alloc_ops/07589b60d038dac2582a99ccead4a4c397c50687 new file mode 100644 index 0000000..c95ba14 Binary files /dev/null and b/fuzz/corpus/alloc_ops/07589b60d038dac2582a99ccead4a4c397c50687 differ diff --git a/fuzz/corpus/alloc_ops/075a83e3b196b49746ecaab34049af56f30df7f7 b/fuzz/corpus/alloc_ops/075a83e3b196b49746ecaab34049af56f30df7f7 new file mode 100644 index 0000000..449f989 Binary files /dev/null and b/fuzz/corpus/alloc_ops/075a83e3b196b49746ecaab34049af56f30df7f7 differ diff --git a/fuzz/corpus/alloc_ops/076926fe38e2b0e8ae44e4fb05c5957f5ac390e0 b/fuzz/corpus/alloc_ops/076926fe38e2b0e8ae44e4fb05c5957f5ac390e0 new file mode 100644 index 0000000..8f48965 Binary files /dev/null and b/fuzz/corpus/alloc_ops/076926fe38e2b0e8ae44e4fb05c5957f5ac390e0 differ diff --git a/fuzz/corpus/alloc_ops/07977d31fdab5f7ec37f4e8d724cd8f516d085e3 b/fuzz/corpus/alloc_ops/07977d31fdab5f7ec37f4e8d724cd8f516d085e3 new file mode 100644 index 0000000..4eaaca3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/07977d31fdab5f7ec37f4e8d724cd8f516d085e3 differ diff --git a/fuzz/corpus/alloc_ops/07a403fd6ae475ebde1730930441e422ae25dd3c b/fuzz/corpus/alloc_ops/07a403fd6ae475ebde1730930441e422ae25dd3c new file mode 100644 index 0000000..990dfdc Binary files /dev/null and b/fuzz/corpus/alloc_ops/07a403fd6ae475ebde1730930441e422ae25dd3c differ diff --git a/fuzz/corpus/alloc_ops/07c118a40c2d9b7ce4e80a6ff58ff937d7138487 b/fuzz/corpus/alloc_ops/07c118a40c2d9b7ce4e80a6ff58ff937d7138487 new file mode 100644 index 0000000..39a229a Binary files /dev/null and b/fuzz/corpus/alloc_ops/07c118a40c2d9b7ce4e80a6ff58ff937d7138487 differ diff --git a/fuzz/corpus/alloc_ops/07da7570a8e6beac7fe56170a7ab3499244b21bc b/fuzz/corpus/alloc_ops/07da7570a8e6beac7fe56170a7ab3499244b21bc new file mode 100644 index 0000000..8df72f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/07da7570a8e6beac7fe56170a7ab3499244b21bc differ diff --git a/fuzz/corpus/alloc_ops/080c521560209c0b1920389c264a9c040dd94428 b/fuzz/corpus/alloc_ops/080c521560209c0b1920389c264a9c040dd94428 new file mode 100644 index 0000000..52e0df3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/080c521560209c0b1920389c264a9c040dd94428 differ diff --git a/fuzz/corpus/alloc_ops/08ca3be82615634a61626c06a32cd46448723926 b/fuzz/corpus/alloc_ops/08ca3be82615634a61626c06a32cd46448723926 new file mode 100644 index 0000000..8475d91 Binary files /dev/null and b/fuzz/corpus/alloc_ops/08ca3be82615634a61626c06a32cd46448723926 differ diff --git a/fuzz/corpus/alloc_ops/08d7cd66c80f644c07fa929a1a8d52404f5ee416 b/fuzz/corpus/alloc_ops/08d7cd66c80f644c07fa929a1a8d52404f5ee416 new file mode 100644 index 0000000..fae5001 Binary files /dev/null and b/fuzz/corpus/alloc_ops/08d7cd66c80f644c07fa929a1a8d52404f5ee416 differ diff --git a/fuzz/corpus/alloc_ops/08e9dbc402208b40b76ef8918d1610b712eade0c b/fuzz/corpus/alloc_ops/08e9dbc402208b40b76ef8918d1610b712eade0c new file mode 100644 index 0000000..ce4f728 Binary files /dev/null and b/fuzz/corpus/alloc_ops/08e9dbc402208b40b76ef8918d1610b712eade0c differ diff --git a/fuzz/corpus/alloc_ops/090d5d2940fe85c3cc294e8f6ee7a9fbf7415e2c b/fuzz/corpus/alloc_ops/090d5d2940fe85c3cc294e8f6ee7a9fbf7415e2c new file mode 100644 index 0000000..42a1cee Binary files /dev/null and b/fuzz/corpus/alloc_ops/090d5d2940fe85c3cc294e8f6ee7a9fbf7415e2c differ diff --git a/fuzz/corpus/alloc_ops/0916d839a31fa679170131c04c85e798c226aac7 b/fuzz/corpus/alloc_ops/0916d839a31fa679170131c04c85e798c226aac7 new file mode 100644 index 0000000..0be2f32 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0916d839a31fa679170131c04c85e798c226aac7 differ diff --git a/fuzz/corpus/alloc_ops/091aff901833ab2926c2cd3b9e541296e2be203e b/fuzz/corpus/alloc_ops/091aff901833ab2926c2cd3b9e541296e2be203e new file mode 100644 index 0000000..f3144ac Binary files /dev/null and b/fuzz/corpus/alloc_ops/091aff901833ab2926c2cd3b9e541296e2be203e differ diff --git a/fuzz/corpus/alloc_ops/09a8b3d15c6485f758761738f76e6cedc6968045 b/fuzz/corpus/alloc_ops/09a8b3d15c6485f758761738f76e6cedc6968045 new file mode 100644 index 0000000..85fb048 Binary files /dev/null and b/fuzz/corpus/alloc_ops/09a8b3d15c6485f758761738f76e6cedc6968045 differ diff --git a/fuzz/corpus/alloc_ops/09cb5fd29b306bd3480164352b8eb51e82226c4c b/fuzz/corpus/alloc_ops/09cb5fd29b306bd3480164352b8eb51e82226c4c new file mode 100644 index 0000000..0ba21cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/09cb5fd29b306bd3480164352b8eb51e82226c4c differ diff --git a/fuzz/corpus/alloc_ops/0a1e1f3e34f43eba707f5b946360be9058b8c670 b/fuzz/corpus/alloc_ops/0a1e1f3e34f43eba707f5b946360be9058b8c670 new file mode 100644 index 0000000..e78b3b7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0a1e1f3e34f43eba707f5b946360be9058b8c670 differ diff --git a/fuzz/corpus/alloc_ops/0a41b0d611075b0517de0cf4e2a8d1e7d410f39c b/fuzz/corpus/alloc_ops/0a41b0d611075b0517de0cf4e2a8d1e7d410f39c new file mode 100644 index 0000000..7f3b533 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0a41b0d611075b0517de0cf4e2a8d1e7d410f39c differ diff --git a/fuzz/corpus/alloc_ops/0a865840657694a6ec550de063086f7b00355ce1 b/fuzz/corpus/alloc_ops/0a865840657694a6ec550de063086f7b00355ce1 new file mode 100644 index 0000000..3ca333b Binary files /dev/null and b/fuzz/corpus/alloc_ops/0a865840657694a6ec550de063086f7b00355ce1 differ diff --git a/fuzz/corpus/alloc_ops/0ab13c9d99cc50690d7821fe8878708f1b18a7e5 b/fuzz/corpus/alloc_ops/0ab13c9d99cc50690d7821fe8878708f1b18a7e5 new file mode 100644 index 0000000..1a5f83a Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ab13c9d99cc50690d7821fe8878708f1b18a7e5 differ diff --git a/fuzz/corpus/alloc_ops/0ab1ca73832a7d89331ac318ea03c6895d103cce b/fuzz/corpus/alloc_ops/0ab1ca73832a7d89331ac318ea03c6895d103cce new file mode 100644 index 0000000..8ebcb5b Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ab1ca73832a7d89331ac318ea03c6895d103cce differ diff --git a/fuzz/corpus/alloc_ops/0acfb90beb9dfbd4e3ee40c31ee653c52367cace b/fuzz/corpus/alloc_ops/0acfb90beb9dfbd4e3ee40c31ee653c52367cace new file mode 100644 index 0000000..99715e8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0acfb90beb9dfbd4e3ee40c31ee653c52367cace differ diff --git a/fuzz/corpus/alloc_ops/0afdb31eb7d8432a9cf4c94daefc246a9678af36 b/fuzz/corpus/alloc_ops/0afdb31eb7d8432a9cf4c94daefc246a9678af36 new file mode 100644 index 0000000..ee3e4cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/0afdb31eb7d8432a9cf4c94daefc246a9678af36 differ diff --git a/fuzz/corpus/alloc_ops/0b4d375b115a7d3eedbf1a371ab529af24657e08 b/fuzz/corpus/alloc_ops/0b4d375b115a7d3eedbf1a371ab529af24657e08 new file mode 100644 index 0000000..b718069 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b4d375b115a7d3eedbf1a371ab529af24657e08 differ diff --git a/fuzz/corpus/alloc_ops/0b66f4a030421f2e23a433e943e27ea8d4676c7d b/fuzz/corpus/alloc_ops/0b66f4a030421f2e23a433e943e27ea8d4676c7d new file mode 100644 index 0000000..189a00e Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b66f4a030421f2e23a433e943e27ea8d4676c7d differ diff --git a/fuzz/corpus/alloc_ops/0b7eaf6f47f7d48518d6b7fa3058fcccd5bfee7c b/fuzz/corpus/alloc_ops/0b7eaf6f47f7d48518d6b7fa3058fcccd5bfee7c new file mode 100644 index 0000000..8a2b16f --- /dev/null +++ b/fuzz/corpus/alloc_ops/0b7eaf6f47f7d48518d6b7fa3058fcccd5bfee7c @@ -0,0 +1 @@ +—h \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/0b86e6e097833af9d4fbbfa4893e44c2dde4216a b/fuzz/corpus/alloc_ops/0b86e6e097833af9d4fbbfa4893e44c2dde4216a new file mode 100644 index 0000000..d8bb25e Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b86e6e097833af9d4fbbfa4893e44c2dde4216a differ diff --git a/fuzz/corpus/alloc_ops/0b9d5e8dc555a6834229181a46e9c3ddf0598ef5 b/fuzz/corpus/alloc_ops/0b9d5e8dc555a6834229181a46e9c3ddf0598ef5 new file mode 100644 index 0000000..02b5d23 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b9d5e8dc555a6834229181a46e9c3ddf0598ef5 differ diff --git a/fuzz/corpus/alloc_ops/0b9dd8fad0bac2afe333f7c7c97d45199ec6a64b b/fuzz/corpus/alloc_ops/0b9dd8fad0bac2afe333f7c7c97d45199ec6a64b new file mode 100644 index 0000000..0ba46a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b9dd8fad0bac2afe333f7c7c97d45199ec6a64b differ diff --git a/fuzz/corpus/alloc_ops/0b9fd76284f43cd7f433fa201ea10fdc09c67e70 b/fuzz/corpus/alloc_ops/0b9fd76284f43cd7f433fa201ea10fdc09c67e70 new file mode 100644 index 0000000..00db847 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0b9fd76284f43cd7f433fa201ea10fdc09c67e70 differ diff --git a/fuzz/corpus/alloc_ops/0ba68861d42dc6f78d8149b0650455d4dca1e2a8 b/fuzz/corpus/alloc_ops/0ba68861d42dc6f78d8149b0650455d4dca1e2a8 new file mode 100644 index 0000000..8514528 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ba68861d42dc6f78d8149b0650455d4dca1e2a8 differ diff --git a/fuzz/corpus/alloc_ops/0bdcff23891675d2cbcaa2a38bb5e934a71e6848 b/fuzz/corpus/alloc_ops/0bdcff23891675d2cbcaa2a38bb5e934a71e6848 new file mode 100644 index 0000000..12266c3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0bdcff23891675d2cbcaa2a38bb5e934a71e6848 differ diff --git a/fuzz/corpus/alloc_ops/0be5c249538ec19893f04a7b84c1caca40612334 b/fuzz/corpus/alloc_ops/0be5c249538ec19893f04a7b84c1caca40612334 new file mode 100644 index 0000000..6945aa3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0be5c249538ec19893f04a7b84c1caca40612334 differ diff --git a/fuzz/corpus/alloc_ops/0be765ec90d4c583163b2c7edcb3ee8fcd80197c b/fuzz/corpus/alloc_ops/0be765ec90d4c583163b2c7edcb3ee8fcd80197c new file mode 100644 index 0000000..ae3c247 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0be765ec90d4c583163b2c7edcb3ee8fcd80197c differ diff --git a/fuzz/corpus/alloc_ops/0c2389bbc6c52912d2e5ebbe0fa3e6dbfe68a775 b/fuzz/corpus/alloc_ops/0c2389bbc6c52912d2e5ebbe0fa3e6dbfe68a775 new file mode 100644 index 0000000..8d48dfc --- /dev/null +++ b/fuzz/corpus/alloc_ops/0c2389bbc6c52912d2e5ebbe0fa3e6dbfe68a775 @@ -0,0 +1 @@ +† \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/0c68e74b9b3626b773ab2340f07845b03bb1f1e9 b/fuzz/corpus/alloc_ops/0c68e74b9b3626b773ab2340f07845b03bb1f1e9 new file mode 100644 index 0000000..bd63eff Binary files /dev/null and b/fuzz/corpus/alloc_ops/0c68e74b9b3626b773ab2340f07845b03bb1f1e9 differ diff --git a/fuzz/corpus/alloc_ops/0cb8d84fd04cdf36501b9a3fc1280d0dc335652f b/fuzz/corpus/alloc_ops/0cb8d84fd04cdf36501b9a3fc1280d0dc335652f new file mode 100644 index 0000000..1805135 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0cb8d84fd04cdf36501b9a3fc1280d0dc335652f differ diff --git a/fuzz/corpus/alloc_ops/0cd7a1a670ff30bd5e2f1b9b628bd848428454d9 b/fuzz/corpus/alloc_ops/0cd7a1a670ff30bd5e2f1b9b628bd848428454d9 new file mode 100644 index 0000000..0120597 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0cd7a1a670ff30bd5e2f1b9b628bd848428454d9 differ diff --git a/fuzz/corpus/alloc_ops/0ceb413940d9c8c69bcb89cc7450f9e24e5eed49 b/fuzz/corpus/alloc_ops/0ceb413940d9c8c69bcb89cc7450f9e24e5eed49 new file mode 100644 index 0000000..b977fbe Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ceb413940d9c8c69bcb89cc7450f9e24e5eed49 differ diff --git a/fuzz/corpus/alloc_ops/0d0ba02b6d8fa66c7e5c77094d5cf2467758d3b7 b/fuzz/corpus/alloc_ops/0d0ba02b6d8fa66c7e5c77094d5cf2467758d3b7 new file mode 100644 index 0000000..69b069d Binary files /dev/null and b/fuzz/corpus/alloc_ops/0d0ba02b6d8fa66c7e5c77094d5cf2467758d3b7 differ diff --git a/fuzz/corpus/alloc_ops/0d1ab2c10ba7fb4feabc80e3e8983c2917d22065 b/fuzz/corpus/alloc_ops/0d1ab2c10ba7fb4feabc80e3e8983c2917d22065 new file mode 100644 index 0000000..48d5559 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0d1ab2c10ba7fb4feabc80e3e8983c2917d22065 differ diff --git a/fuzz/corpus/alloc_ops/0db23589af5fe3dccd6d9c72fc2f4d325752ba4d b/fuzz/corpus/alloc_ops/0db23589af5fe3dccd6d9c72fc2f4d325752ba4d new file mode 100644 index 0000000..0c28026 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0db23589af5fe3dccd6d9c72fc2f4d325752ba4d differ diff --git a/fuzz/corpus/alloc_ops/0ddf023687fede94ad43229db2a3e9b8d87b79fd b/fuzz/corpus/alloc_ops/0ddf023687fede94ad43229db2a3e9b8d87b79fd new file mode 100644 index 0000000..5720010 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ddf023687fede94ad43229db2a3e9b8d87b79fd differ diff --git a/fuzz/corpus/alloc_ops/0e394b13886f00f6e04e3da6d3760d81190b8561 b/fuzz/corpus/alloc_ops/0e394b13886f00f6e04e3da6d3760d81190b8561 new file mode 100644 index 0000000..35bdf83 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e394b13886f00f6e04e3da6d3760d81190b8561 differ diff --git a/fuzz/corpus/alloc_ops/0e476a7320d75fd9e66190aa4415b3140de3bb9d b/fuzz/corpus/alloc_ops/0e476a7320d75fd9e66190aa4415b3140de3bb9d new file mode 100644 index 0000000..7ff50f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e476a7320d75fd9e66190aa4415b3140de3bb9d differ diff --git a/fuzz/corpus/alloc_ops/0e70ccc66bcc3177a94981d4b4952c4f57959d2a b/fuzz/corpus/alloc_ops/0e70ccc66bcc3177a94981d4b4952c4f57959d2a new file mode 100644 index 0000000..3cb6c42 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e70ccc66bcc3177a94981d4b4952c4f57959d2a differ diff --git a/fuzz/corpus/alloc_ops/0e85dd57e5658f29c362df7d5b40b33ce7a9f790 b/fuzz/corpus/alloc_ops/0e85dd57e5658f29c362df7d5b40b33ce7a9f790 new file mode 100644 index 0000000..facd450 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e85dd57e5658f29c362df7d5b40b33ce7a9f790 differ diff --git a/fuzz/corpus/alloc_ops/0e87bddc4ecd7c1498bd8d9699eb8d7676424154 b/fuzz/corpus/alloc_ops/0e87bddc4ecd7c1498bd8d9699eb8d7676424154 new file mode 100644 index 0000000..9278c42 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e87bddc4ecd7c1498bd8d9699eb8d7676424154 differ diff --git a/fuzz/corpus/alloc_ops/0e9ad20d497caddec7445f90cab4ece0ca28857e b/fuzz/corpus/alloc_ops/0e9ad20d497caddec7445f90cab4ece0ca28857e new file mode 100644 index 0000000..fcc9734 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0e9ad20d497caddec7445f90cab4ece0ca28857e differ diff --git a/fuzz/corpus/alloc_ops/0ef951c4096017f12eaf1d52e30c56db09b33034 b/fuzz/corpus/alloc_ops/0ef951c4096017f12eaf1d52e30c56db09b33034 new file mode 100644 index 0000000..df5b382 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0ef951c4096017f12eaf1d52e30c56db09b33034 differ diff --git a/fuzz/corpus/alloc_ops/0f214e4ec02adffaba8a318104844d063879d1ab b/fuzz/corpus/alloc_ops/0f214e4ec02adffaba8a318104844d063879d1ab new file mode 100644 index 0000000..46af914 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0f214e4ec02adffaba8a318104844d063879d1ab differ diff --git a/fuzz/corpus/alloc_ops/0f2e4d7b2d48605f25d6143f6860841d737c6105 b/fuzz/corpus/alloc_ops/0f2e4d7b2d48605f25d6143f6860841d737c6105 new file mode 100644 index 0000000..324f1d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0f2e4d7b2d48605f25d6143f6860841d737c6105 differ diff --git a/fuzz/corpus/alloc_ops/0f44222b93a04550db6906a38d36c6e98075d4df b/fuzz/corpus/alloc_ops/0f44222b93a04550db6906a38d36c6e98075d4df new file mode 100644 index 0000000..4221bcb Binary files /dev/null and b/fuzz/corpus/alloc_ops/0f44222b93a04550db6906a38d36c6e98075d4df differ diff --git a/fuzz/corpus/alloc_ops/0f83fe6c223f6cfc052008dfa99b795f04087318 b/fuzz/corpus/alloc_ops/0f83fe6c223f6cfc052008dfa99b795f04087318 new file mode 100644 index 0000000..4c549f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0f83fe6c223f6cfc052008dfa99b795f04087318 differ diff --git a/fuzz/corpus/alloc_ops/0f9707298e5a736d2477425e3791cd42d78495f7 b/fuzz/corpus/alloc_ops/0f9707298e5a736d2477425e3791cd42d78495f7 new file mode 100644 index 0000000..c4c622e Binary files /dev/null and b/fuzz/corpus/alloc_ops/0f9707298e5a736d2477425e3791cd42d78495f7 differ diff --git a/fuzz/corpus/alloc_ops/0faf4a9b7520f367e5464d16ea48e4d4f0207ce3 b/fuzz/corpus/alloc_ops/0faf4a9b7520f367e5464d16ea48e4d4f0207ce3 new file mode 100644 index 0000000..878a27a Binary files /dev/null and b/fuzz/corpus/alloc_ops/0faf4a9b7520f367e5464d16ea48e4d4f0207ce3 differ diff --git a/fuzz/corpus/alloc_ops/0fd2a9d363353b1e999f842a08561d4552d63572 b/fuzz/corpus/alloc_ops/0fd2a9d363353b1e999f842a08561d4552d63572 new file mode 100644 index 0000000..b22293b Binary files /dev/null and b/fuzz/corpus/alloc_ops/0fd2a9d363353b1e999f842a08561d4552d63572 differ diff --git a/fuzz/corpus/alloc_ops/0fdfd00a8055e4ee3c4a0b348d2cd44fd436821f b/fuzz/corpus/alloc_ops/0fdfd00a8055e4ee3c4a0b348d2cd44fd436821f new file mode 100644 index 0000000..58b5ea6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/0fdfd00a8055e4ee3c4a0b348d2cd44fd436821f differ diff --git a/fuzz/corpus/alloc_ops/0fe8ff0cf77e2fefee02ac1745cae27764ebded6 b/fuzz/corpus/alloc_ops/0fe8ff0cf77e2fefee02ac1745cae27764ebded6 new file mode 100644 index 0000000..e736a22 --- /dev/null +++ b/fuzz/corpus/alloc_ops/0fe8ff0cf77e2fefee02ac1745cae27764ebded6 @@ -0,0 +1 @@ +ö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/0fec5e62e54767f34358ace4b7b31be6a5009172 b/fuzz/corpus/alloc_ops/0fec5e62e54767f34358ace4b7b31be6a5009172 new file mode 100644 index 0000000..9323fca Binary files /dev/null and b/fuzz/corpus/alloc_ops/0fec5e62e54767f34358ace4b7b31be6a5009172 differ diff --git a/fuzz/corpus/alloc_ops/1016473833da4fb90e152458ad53c43bd550a19c b/fuzz/corpus/alloc_ops/1016473833da4fb90e152458ad53c43bd550a19c new file mode 100644 index 0000000..0e2ceae --- /dev/null +++ b/fuzz/corpus/alloc_ops/1016473833da4fb90e152458ad53c43bd550a19c @@ -0,0 +1 @@ +ìö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/1024920364216a74271ef91ae1b8eed9b9e80e6c b/fuzz/corpus/alloc_ops/1024920364216a74271ef91ae1b8eed9b9e80e6c new file mode 100644 index 0000000..473ec60 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1024920364216a74271ef91ae1b8eed9b9e80e6c differ diff --git a/fuzz/corpus/alloc_ops/1047b6ec1eee36778c6c261074d9e8ec7e2c4b1d b/fuzz/corpus/alloc_ops/1047b6ec1eee36778c6c261074d9e8ec7e2c4b1d new file mode 100644 index 0000000..352578a Binary files /dev/null and b/fuzz/corpus/alloc_ops/1047b6ec1eee36778c6c261074d9e8ec7e2c4b1d differ diff --git a/fuzz/corpus/alloc_ops/1062690b72ae3dbaf7260a8038f3793f4a2281bc b/fuzz/corpus/alloc_ops/1062690b72ae3dbaf7260a8038f3793f4a2281bc new file mode 100644 index 0000000..5829bb2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1062690b72ae3dbaf7260a8038f3793f4a2281bc differ diff --git a/fuzz/corpus/alloc_ops/107588211f42c4f3f044411b59c43e038698da34 b/fuzz/corpus/alloc_ops/107588211f42c4f3f044411b59c43e038698da34 new file mode 100644 index 0000000..8a56397 Binary files /dev/null and b/fuzz/corpus/alloc_ops/107588211f42c4f3f044411b59c43e038698da34 differ diff --git a/fuzz/corpus/alloc_ops/10b2d920ff01acd197435163fe353459a27ea936 b/fuzz/corpus/alloc_ops/10b2d920ff01acd197435163fe353459a27ea936 new file mode 100644 index 0000000..db524b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/10b2d920ff01acd197435163fe353459a27ea936 differ diff --git a/fuzz/corpus/alloc_ops/10c0033b0188562007acb76395199f055d121eba b/fuzz/corpus/alloc_ops/10c0033b0188562007acb76395199f055d121eba new file mode 100644 index 0000000..39bfd8d Binary files /dev/null and b/fuzz/corpus/alloc_ops/10c0033b0188562007acb76395199f055d121eba differ diff --git a/fuzz/corpus/alloc_ops/10dbc1f52eb0c4f365c51922d43ba124f7b077e9 b/fuzz/corpus/alloc_ops/10dbc1f52eb0c4f365c51922d43ba124f7b077e9 new file mode 100644 index 0000000..49e2501 Binary files /dev/null and b/fuzz/corpus/alloc_ops/10dbc1f52eb0c4f365c51922d43ba124f7b077e9 differ diff --git a/fuzz/corpus/alloc_ops/10f6aabd556f43aa8477004cd2cb78c0cf9706f7 b/fuzz/corpus/alloc_ops/10f6aabd556f43aa8477004cd2cb78c0cf9706f7 new file mode 100644 index 0000000..746520b Binary files /dev/null and b/fuzz/corpus/alloc_ops/10f6aabd556f43aa8477004cd2cb78c0cf9706f7 differ diff --git a/fuzz/corpus/alloc_ops/111f00dc35cea3533ec59257ce4322857c62e81b b/fuzz/corpus/alloc_ops/111f00dc35cea3533ec59257ce4322857c62e81b new file mode 100644 index 0000000..5e3e9d5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/111f00dc35cea3533ec59257ce4322857c62e81b differ diff --git a/fuzz/corpus/alloc_ops/113e4d14e09dcc1cf8aa4be079cd04dab32f4996 b/fuzz/corpus/alloc_ops/113e4d14e09dcc1cf8aa4be079cd04dab32f4996 new file mode 100644 index 0000000..304a5f7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/113e4d14e09dcc1cf8aa4be079cd04dab32f4996 differ diff --git a/fuzz/corpus/alloc_ops/115cb6b75764ef854ab7b654e9b38f909c95e58a b/fuzz/corpus/alloc_ops/115cb6b75764ef854ab7b654e9b38f909c95e58a new file mode 100644 index 0000000..eb72400 Binary files /dev/null and b/fuzz/corpus/alloc_ops/115cb6b75764ef854ab7b654e9b38f909c95e58a differ diff --git a/fuzz/corpus/alloc_ops/11715fc78348da9dc81f9817dc9203423f204974 b/fuzz/corpus/alloc_ops/11715fc78348da9dc81f9817dc9203423f204974 new file mode 100644 index 0000000..8acf5e8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/11715fc78348da9dc81f9817dc9203423f204974 differ diff --git a/fuzz/corpus/alloc_ops/11b8ba3d4a69ec44091f91ff3309eec3fd9e06ed b/fuzz/corpus/alloc_ops/11b8ba3d4a69ec44091f91ff3309eec3fd9e06ed new file mode 100644 index 0000000..f56d697 Binary files /dev/null and b/fuzz/corpus/alloc_ops/11b8ba3d4a69ec44091f91ff3309eec3fd9e06ed differ diff --git a/fuzz/corpus/alloc_ops/11ddd8f82bc09aceae95e14d86833229ab80f4f6 b/fuzz/corpus/alloc_ops/11ddd8f82bc09aceae95e14d86833229ab80f4f6 new file mode 100644 index 0000000..0871031 Binary files /dev/null and b/fuzz/corpus/alloc_ops/11ddd8f82bc09aceae95e14d86833229ab80f4f6 differ diff --git a/fuzz/corpus/alloc_ops/11f06475754d69bd9c71521b7f75289c70df6ef3 b/fuzz/corpus/alloc_ops/11f06475754d69bd9c71521b7f75289c70df6ef3 new file mode 100644 index 0000000..8fc60a5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/11f06475754d69bd9c71521b7f75289c70df6ef3 differ diff --git a/fuzz/corpus/alloc_ops/11fa2f9ea87eae6b105be88468645e060f0e8252 b/fuzz/corpus/alloc_ops/11fa2f9ea87eae6b105be88468645e060f0e8252 new file mode 100644 index 0000000..deba179 Binary files /dev/null and b/fuzz/corpus/alloc_ops/11fa2f9ea87eae6b105be88468645e060f0e8252 differ diff --git a/fuzz/corpus/alloc_ops/1243f7f410377df4c4d171fc8971dadadedf4db2 b/fuzz/corpus/alloc_ops/1243f7f410377df4c4d171fc8971dadadedf4db2 new file mode 100644 index 0000000..d71ddb1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1243f7f410377df4c4d171fc8971dadadedf4db2 differ diff --git a/fuzz/corpus/alloc_ops/1252350d116d15a5f31f01ffbb9c82b0eb959210 b/fuzz/corpus/alloc_ops/1252350d116d15a5f31f01ffbb9c82b0eb959210 new file mode 100644 index 0000000..76ccc3e Binary files /dev/null and b/fuzz/corpus/alloc_ops/1252350d116d15a5f31f01ffbb9c82b0eb959210 differ diff --git a/fuzz/corpus/alloc_ops/125c5b4d3a1d59fc5b87e9cb0de8e2304b8edc43 b/fuzz/corpus/alloc_ops/125c5b4d3a1d59fc5b87e9cb0de8e2304b8edc43 new file mode 100644 index 0000000..384e708 Binary files /dev/null and b/fuzz/corpus/alloc_ops/125c5b4d3a1d59fc5b87e9cb0de8e2304b8edc43 differ diff --git a/fuzz/corpus/alloc_ops/127c441f166fdffb04c9517c2cd3069c7084ecc4 b/fuzz/corpus/alloc_ops/127c441f166fdffb04c9517c2cd3069c7084ecc4 new file mode 100644 index 0000000..94e9bc3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/127c441f166fdffb04c9517c2cd3069c7084ecc4 differ diff --git a/fuzz/corpus/alloc_ops/12f18960eb1c162d036694b3a557d2bd33201182 b/fuzz/corpus/alloc_ops/12f18960eb1c162d036694b3a557d2bd33201182 new file mode 100644 index 0000000..8d783c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/12f18960eb1c162d036694b3a557d2bd33201182 differ diff --git a/fuzz/corpus/alloc_ops/132974f9f61fe88a38aa24c098e04142bbfd5f44 b/fuzz/corpus/alloc_ops/132974f9f61fe88a38aa24c098e04142bbfd5f44 new file mode 100644 index 0000000..ba44d68 Binary files /dev/null and b/fuzz/corpus/alloc_ops/132974f9f61fe88a38aa24c098e04142bbfd5f44 differ diff --git a/fuzz/corpus/alloc_ops/134055dda6a998599a36354bac55402ff04c79d9 b/fuzz/corpus/alloc_ops/134055dda6a998599a36354bac55402ff04c79d9 new file mode 100644 index 0000000..e2f32ac Binary files /dev/null and b/fuzz/corpus/alloc_ops/134055dda6a998599a36354bac55402ff04c79d9 differ diff --git a/fuzz/corpus/alloc_ops/1381b57cd88a63a55342a3b997b72fddab3d2aee b/fuzz/corpus/alloc_ops/1381b57cd88a63a55342a3b997b72fddab3d2aee new file mode 100644 index 0000000..6be9c36 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1381b57cd88a63a55342a3b997b72fddab3d2aee differ diff --git a/fuzz/corpus/alloc_ops/138a6246e7e070d64c7e8431e5da947d49434639 b/fuzz/corpus/alloc_ops/138a6246e7e070d64c7e8431e5da947d49434639 new file mode 100644 index 0000000..a003dd8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/138a6246e7e070d64c7e8431e5da947d49434639 differ diff --git a/fuzz/corpus/alloc_ops/138ff783290fd3713395249c7f07f7d29f8be899 b/fuzz/corpus/alloc_ops/138ff783290fd3713395249c7f07f7d29f8be899 new file mode 100644 index 0000000..0c245d5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/138ff783290fd3713395249c7f07f7d29f8be899 differ diff --git a/fuzz/corpus/alloc_ops/13ade192388eb05ac04d09f6f435de16f17428bc b/fuzz/corpus/alloc_ops/13ade192388eb05ac04d09f6f435de16f17428bc new file mode 100644 index 0000000..34b035e Binary files /dev/null and b/fuzz/corpus/alloc_ops/13ade192388eb05ac04d09f6f435de16f17428bc differ diff --git a/fuzz/corpus/alloc_ops/141df10137304555bb91d61e7ce759fc438afbce b/fuzz/corpus/alloc_ops/141df10137304555bb91d61e7ce759fc438afbce new file mode 100644 index 0000000..fcf19e7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/141df10137304555bb91d61e7ce759fc438afbce differ diff --git a/fuzz/corpus/alloc_ops/143d6f175088b17a8c1576542920613356ac5324 b/fuzz/corpus/alloc_ops/143d6f175088b17a8c1576542920613356ac5324 new file mode 100644 index 0000000..fd757ef Binary files /dev/null and b/fuzz/corpus/alloc_ops/143d6f175088b17a8c1576542920613356ac5324 differ diff --git a/fuzz/corpus/alloc_ops/149a238fc98003010d452eac1c67c5ce84203da3 b/fuzz/corpus/alloc_ops/149a238fc98003010d452eac1c67c5ce84203da3 new file mode 100644 index 0000000..e7cb09d Binary files /dev/null and b/fuzz/corpus/alloc_ops/149a238fc98003010d452eac1c67c5ce84203da3 differ diff --git a/fuzz/corpus/alloc_ops/14fa162bc36c5f1f1559e254899c0ec09be390e9 b/fuzz/corpus/alloc_ops/14fa162bc36c5f1f1559e254899c0ec09be390e9 new file mode 100644 index 0000000..45a12f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/14fa162bc36c5f1f1559e254899c0ec09be390e9 differ diff --git a/fuzz/corpus/alloc_ops/15118d9785c1de5da8e494e45c748f885d57a489 b/fuzz/corpus/alloc_ops/15118d9785c1de5da8e494e45c748f885d57a489 new file mode 100644 index 0000000..f7d7bb3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/15118d9785c1de5da8e494e45c748f885d57a489 differ diff --git a/fuzz/corpus/alloc_ops/1518989e9eed05f845f1903fcf47bce6267ef830 b/fuzz/corpus/alloc_ops/1518989e9eed05f845f1903fcf47bce6267ef830 new file mode 100644 index 0000000..20b7d46 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1518989e9eed05f845f1903fcf47bce6267ef830 differ diff --git a/fuzz/corpus/alloc_ops/15297cbd3560c26f99a1beea8a2f11b2c92a1628 b/fuzz/corpus/alloc_ops/15297cbd3560c26f99a1beea8a2f11b2c92a1628 new file mode 100644 index 0000000..7402bda Binary files /dev/null and b/fuzz/corpus/alloc_ops/15297cbd3560c26f99a1beea8a2f11b2c92a1628 differ diff --git a/fuzz/corpus/alloc_ops/15b213871ebf3cce56710a94dbfab4154944ea5a b/fuzz/corpus/alloc_ops/15b213871ebf3cce56710a94dbfab4154944ea5a new file mode 100644 index 0000000..db703c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/15b213871ebf3cce56710a94dbfab4154944ea5a differ diff --git a/fuzz/corpus/alloc_ops/15f91c8a629f7503bef5b837aacf5082bd14d714 b/fuzz/corpus/alloc_ops/15f91c8a629f7503bef5b837aacf5082bd14d714 new file mode 100644 index 0000000..9fd8af7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/15f91c8a629f7503bef5b837aacf5082bd14d714 differ diff --git a/fuzz/corpus/alloc_ops/1603f921f1d95b848559b497a01cf4fe36d962f5 b/fuzz/corpus/alloc_ops/1603f921f1d95b848559b497a01cf4fe36d962f5 new file mode 100644 index 0000000..7812903 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1603f921f1d95b848559b497a01cf4fe36d962f5 differ diff --git a/fuzz/corpus/alloc_ops/161cbf87a53c15034a45f25c0dc6eab19e70085b b/fuzz/corpus/alloc_ops/161cbf87a53c15034a45f25c0dc6eab19e70085b new file mode 100644 index 0000000..fb693d4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/161cbf87a53c15034a45f25c0dc6eab19e70085b differ diff --git a/fuzz/corpus/alloc_ops/16678c89e812bcecf430f0410a9a0678e0f0f6a1 b/fuzz/corpus/alloc_ops/16678c89e812bcecf430f0410a9a0678e0f0f6a1 new file mode 100644 index 0000000..a0db4a6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/16678c89e812bcecf430f0410a9a0678e0f0f6a1 differ diff --git a/fuzz/corpus/alloc_ops/1674eca29f50389f4f4b12065fc52eeefc23139b b/fuzz/corpus/alloc_ops/1674eca29f50389f4f4b12065fc52eeefc23139b new file mode 100644 index 0000000..4dbb2a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1674eca29f50389f4f4b12065fc52eeefc23139b differ diff --git a/fuzz/corpus/alloc_ops/16a3d87386ec1f00adce252af3f83055e1c2ee9b b/fuzz/corpus/alloc_ops/16a3d87386ec1f00adce252af3f83055e1c2ee9b new file mode 100644 index 0000000..5fe80bc Binary files /dev/null and b/fuzz/corpus/alloc_ops/16a3d87386ec1f00adce252af3f83055e1c2ee9b differ diff --git a/fuzz/corpus/alloc_ops/16aeb897af1d10b72a0baee1515ff926aa259ed3 b/fuzz/corpus/alloc_ops/16aeb897af1d10b72a0baee1515ff926aa259ed3 new file mode 100644 index 0000000..c283547 Binary files /dev/null and b/fuzz/corpus/alloc_ops/16aeb897af1d10b72a0baee1515ff926aa259ed3 differ diff --git a/fuzz/corpus/alloc_ops/16f3027bed1254fe9bf8f3a382aaede06dec4c66 b/fuzz/corpus/alloc_ops/16f3027bed1254fe9bf8f3a382aaede06dec4c66 new file mode 100644 index 0000000..d5765f3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/16f3027bed1254fe9bf8f3a382aaede06dec4c66 differ diff --git a/fuzz/corpus/alloc_ops/172bab8e17768a7f9804d064426ce81977780bb4 b/fuzz/corpus/alloc_ops/172bab8e17768a7f9804d064426ce81977780bb4 new file mode 100644 index 0000000..8ab6b3e Binary files /dev/null and b/fuzz/corpus/alloc_ops/172bab8e17768a7f9804d064426ce81977780bb4 differ diff --git a/fuzz/corpus/alloc_ops/174dbd18f9e014666f8c79796c5f31aacab3bcef b/fuzz/corpus/alloc_ops/174dbd18f9e014666f8c79796c5f31aacab3bcef new file mode 100644 index 0000000..c60e7b5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/174dbd18f9e014666f8c79796c5f31aacab3bcef differ diff --git a/fuzz/corpus/alloc_ops/17b77e96e5409cb53b389569d3442102adf9a317 b/fuzz/corpus/alloc_ops/17b77e96e5409cb53b389569d3442102adf9a317 new file mode 100644 index 0000000..00c2867 Binary files /dev/null and b/fuzz/corpus/alloc_ops/17b77e96e5409cb53b389569d3442102adf9a317 differ diff --git a/fuzz/corpus/alloc_ops/17be0649214c412487c0811c4f2af07616464eb2 b/fuzz/corpus/alloc_ops/17be0649214c412487c0811c4f2af07616464eb2 new file mode 100644 index 0000000..0d89c35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/17be0649214c412487c0811c4f2af07616464eb2 differ diff --git a/fuzz/corpus/alloc_ops/1844b978a84000d0aceac260db6079426c83bb18 b/fuzz/corpus/alloc_ops/1844b978a84000d0aceac260db6079426c83bb18 new file mode 100644 index 0000000..9917d5a Binary files /dev/null and b/fuzz/corpus/alloc_ops/1844b978a84000d0aceac260db6079426c83bb18 differ diff --git a/fuzz/corpus/alloc_ops/1851b2736f3dde52b63bfe49fd6691969d7f22c4 b/fuzz/corpus/alloc_ops/1851b2736f3dde52b63bfe49fd6691969d7f22c4 new file mode 100644 index 0000000..928a1a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1851b2736f3dde52b63bfe49fd6691969d7f22c4 differ diff --git a/fuzz/corpus/alloc_ops/185727aac1452648dd4f74f55e617c3a45432c1c b/fuzz/corpus/alloc_ops/185727aac1452648dd4f74f55e617c3a45432c1c new file mode 100644 index 0000000..5ab4293 Binary files /dev/null and b/fuzz/corpus/alloc_ops/185727aac1452648dd4f74f55e617c3a45432c1c differ diff --git a/fuzz/corpus/alloc_ops/18b2b10e87f03e52799b08df59f3069c724d2b87 b/fuzz/corpus/alloc_ops/18b2b10e87f03e52799b08df59f3069c724d2b87 new file mode 100644 index 0000000..d9dde91 Binary files /dev/null and b/fuzz/corpus/alloc_ops/18b2b10e87f03e52799b08df59f3069c724d2b87 differ diff --git a/fuzz/corpus/alloc_ops/18e72ccc0e55e4bbc4754c0d5067d389fc8096ce b/fuzz/corpus/alloc_ops/18e72ccc0e55e4bbc4754c0d5067d389fc8096ce new file mode 100644 index 0000000..bba0743 Binary files /dev/null and b/fuzz/corpus/alloc_ops/18e72ccc0e55e4bbc4754c0d5067d389fc8096ce differ diff --git a/fuzz/corpus/alloc_ops/19038ffdc52d3241e6d53651640001eb8534ff07 b/fuzz/corpus/alloc_ops/19038ffdc52d3241e6d53651640001eb8534ff07 new file mode 100644 index 0000000..7cb567f Binary files /dev/null and b/fuzz/corpus/alloc_ops/19038ffdc52d3241e6d53651640001eb8534ff07 differ diff --git a/fuzz/corpus/alloc_ops/19196a2061274d7d79a250bc03e1bd55fc97a3d0 b/fuzz/corpus/alloc_ops/19196a2061274d7d79a250bc03e1bd55fc97a3d0 new file mode 100644 index 0000000..211c4dd Binary files /dev/null and b/fuzz/corpus/alloc_ops/19196a2061274d7d79a250bc03e1bd55fc97a3d0 differ diff --git a/fuzz/corpus/alloc_ops/193796cbfcf65ed00e2c45068b1dd52519591ce5 b/fuzz/corpus/alloc_ops/193796cbfcf65ed00e2c45068b1dd52519591ce5 new file mode 100644 index 0000000..6a7fdd3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/193796cbfcf65ed00e2c45068b1dd52519591ce5 differ diff --git a/fuzz/corpus/alloc_ops/193d49504f49674b5fc7597b5109d5000790efe5 b/fuzz/corpus/alloc_ops/193d49504f49674b5fc7597b5109d5000790efe5 new file mode 100644 index 0000000..9e7c70f Binary files /dev/null and b/fuzz/corpus/alloc_ops/193d49504f49674b5fc7597b5109d5000790efe5 differ diff --git a/fuzz/corpus/alloc_ops/194c14fa83b62f88cd12af795def33d8226ae17b b/fuzz/corpus/alloc_ops/194c14fa83b62f88cd12af795def33d8226ae17b new file mode 100644 index 0000000..65240f3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/194c14fa83b62f88cd12af795def33d8226ae17b differ diff --git a/fuzz/corpus/alloc_ops/195d399cc539d816753d4c133e93b2fd1b43d4d9 b/fuzz/corpus/alloc_ops/195d399cc539d816753d4c133e93b2fd1b43d4d9 new file mode 100644 index 0000000..b58a1e5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/195d399cc539d816753d4c133e93b2fd1b43d4d9 differ diff --git a/fuzz/corpus/alloc_ops/19b22a0cd7ebb94ae6357354b90b9b0eb34d0f7e b/fuzz/corpus/alloc_ops/19b22a0cd7ebb94ae6357354b90b9b0eb34d0f7e new file mode 100644 index 0000000..1857cf2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/19b22a0cd7ebb94ae6357354b90b9b0eb34d0f7e differ diff --git a/fuzz/corpus/alloc_ops/19bb2e0fd8c39bea9b19e6840d45a1348206d61a b/fuzz/corpus/alloc_ops/19bb2e0fd8c39bea9b19e6840d45a1348206d61a new file mode 100644 index 0000000..03f4016 Binary files /dev/null and b/fuzz/corpus/alloc_ops/19bb2e0fd8c39bea9b19e6840d45a1348206d61a differ diff --git a/fuzz/corpus/alloc_ops/19c6734ccf1b25defea6c937656eba7ffb35d5e9 b/fuzz/corpus/alloc_ops/19c6734ccf1b25defea6c937656eba7ffb35d5e9 new file mode 100644 index 0000000..aa7f777 Binary files /dev/null and b/fuzz/corpus/alloc_ops/19c6734ccf1b25defea6c937656eba7ffb35d5e9 differ diff --git a/fuzz/corpus/alloc_ops/19e415615ca10eb7821fcff3e9ac9feff563adf4 b/fuzz/corpus/alloc_ops/19e415615ca10eb7821fcff3e9ac9feff563adf4 new file mode 100644 index 0000000..9d285e7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/19e415615ca10eb7821fcff3e9ac9feff563adf4 differ diff --git a/fuzz/corpus/alloc_ops/19faf56a02907b70f3122214237845e236a1f9ad b/fuzz/corpus/alloc_ops/19faf56a02907b70f3122214237845e236a1f9ad new file mode 100644 index 0000000..8e7f974 Binary files /dev/null and b/fuzz/corpus/alloc_ops/19faf56a02907b70f3122214237845e236a1f9ad differ diff --git a/fuzz/corpus/alloc_ops/1a1d9163ffff7a3e062cb03bf32a0b6a0a57df69 b/fuzz/corpus/alloc_ops/1a1d9163ffff7a3e062cb03bf32a0b6a0a57df69 new file mode 100644 index 0000000..22527eb Binary files /dev/null and b/fuzz/corpus/alloc_ops/1a1d9163ffff7a3e062cb03bf32a0b6a0a57df69 differ diff --git a/fuzz/corpus/alloc_ops/1a36ac8ce83b6ccc7ba46fb7195c43054cb0d012 b/fuzz/corpus/alloc_ops/1a36ac8ce83b6ccc7ba46fb7195c43054cb0d012 new file mode 100644 index 0000000..55a1ceb Binary files /dev/null and b/fuzz/corpus/alloc_ops/1a36ac8ce83b6ccc7ba46fb7195c43054cb0d012 differ diff --git a/fuzz/corpus/alloc_ops/1a68d36e4d181c1b215e6471043c05eff3d7447b b/fuzz/corpus/alloc_ops/1a68d36e4d181c1b215e6471043c05eff3d7447b new file mode 100644 index 0000000..83ed0d0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1a68d36e4d181c1b215e6471043c05eff3d7447b differ diff --git a/fuzz/corpus/alloc_ops/1a78a359637367bd2e35610f33f07da394c71959 b/fuzz/corpus/alloc_ops/1a78a359637367bd2e35610f33f07da394c71959 new file mode 100644 index 0000000..53b1f30 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1a78a359637367bd2e35610f33f07da394c71959 differ diff --git a/fuzz/corpus/alloc_ops/1af33b87370fb4f734feb3142189fb4a5d3f8e26 b/fuzz/corpus/alloc_ops/1af33b87370fb4f734feb3142189fb4a5d3f8e26 new file mode 100644 index 0000000..c9deb6c Binary files /dev/null and b/fuzz/corpus/alloc_ops/1af33b87370fb4f734feb3142189fb4a5d3f8e26 differ diff --git a/fuzz/corpus/alloc_ops/1b0db8b8cdec4355afe33379f8317fa1610160f7 b/fuzz/corpus/alloc_ops/1b0db8b8cdec4355afe33379f8317fa1610160f7 new file mode 100644 index 0000000..3410932 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1b0db8b8cdec4355afe33379f8317fa1610160f7 differ diff --git a/fuzz/corpus/alloc_ops/1b16ae27b744aa99753fe71b7a43899586a3cca6 b/fuzz/corpus/alloc_ops/1b16ae27b744aa99753fe71b7a43899586a3cca6 new file mode 100644 index 0000000..4a9626a Binary files /dev/null and b/fuzz/corpus/alloc_ops/1b16ae27b744aa99753fe71b7a43899586a3cca6 differ diff --git a/fuzz/corpus/alloc_ops/1b551b17322577dae1b09cfb0b947389419d489c b/fuzz/corpus/alloc_ops/1b551b17322577dae1b09cfb0b947389419d489c new file mode 100644 index 0000000..db02d0b --- /dev/null +++ b/fuzz/corpus/alloc_ops/1b551b17322577dae1b09cfb0b947389419d489c @@ -0,0 +1 @@ +þþþþþþþþþþþ¤þþþþþþþ#Aþþþþþþþþþþþþþþþþ#2þþþþþþþþþþþþþþþþþþþ$þ]þÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/1b6521dd4e2f9e2c1b7d5e5c5e8cee3f6c6a6a03 b/fuzz/corpus/alloc_ops/1b6521dd4e2f9e2c1b7d5e5c5e8cee3f6c6a6a03 new file mode 100644 index 0000000..79210c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1b6521dd4e2f9e2c1b7d5e5c5e8cee3f6c6a6a03 differ diff --git a/fuzz/corpus/alloc_ops/1b7041b544e87224f22c558240338a584c39481d b/fuzz/corpus/alloc_ops/1b7041b544e87224f22c558240338a584c39481d new file mode 100644 index 0000000..d6b6060 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1b7041b544e87224f22c558240338a584c39481d differ diff --git a/fuzz/corpus/alloc_ops/1b87667a4df2188e225db0098d0b40897b1f9d09 b/fuzz/corpus/alloc_ops/1b87667a4df2188e225db0098d0b40897b1f9d09 new file mode 100644 index 0000000..421b390 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1b87667a4df2188e225db0098d0b40897b1f9d09 differ diff --git a/fuzz/corpus/alloc_ops/1bda43583d78ae6df77ca7c58dae66925ca2f0b8 b/fuzz/corpus/alloc_ops/1bda43583d78ae6df77ca7c58dae66925ca2f0b8 new file mode 100644 index 0000000..866f4c2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1bda43583d78ae6df77ca7c58dae66925ca2f0b8 differ diff --git a/fuzz/corpus/alloc_ops/1c5c3efda4007dc52e979ca7f441c4cf7859a873 b/fuzz/corpus/alloc_ops/1c5c3efda4007dc52e979ca7f441c4cf7859a873 new file mode 100644 index 0000000..3567dd2 --- /dev/null +++ b/fuzz/corpus/alloc_ops/1c5c3efda4007dc52e979ca7f441c4cf7859a873 @@ -0,0 +1 @@ +æ™ìö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/1cdbf7e8a3d9191c57162595cc7de3e3a0f5ea02 b/fuzz/corpus/alloc_ops/1cdbf7e8a3d9191c57162595cc7de3e3a0f5ea02 new file mode 100644 index 0000000..e7b7f60 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1cdbf7e8a3d9191c57162595cc7de3e3a0f5ea02 differ diff --git a/fuzz/corpus/alloc_ops/1d406b9a1320aed7b3e14820d3eee0b2d6e41316 b/fuzz/corpus/alloc_ops/1d406b9a1320aed7b3e14820d3eee0b2d6e41316 new file mode 100644 index 0000000..907b7fc Binary files /dev/null and b/fuzz/corpus/alloc_ops/1d406b9a1320aed7b3e14820d3eee0b2d6e41316 differ diff --git a/fuzz/corpus/alloc_ops/1d4330f331b6019ee7457ce45170ae1c25e4d198 b/fuzz/corpus/alloc_ops/1d4330f331b6019ee7457ce45170ae1c25e4d198 new file mode 100644 index 0000000..ae8e71a Binary files /dev/null and b/fuzz/corpus/alloc_ops/1d4330f331b6019ee7457ce45170ae1c25e4d198 differ diff --git a/fuzz/corpus/alloc_ops/1d872b4d74787ef0d1ff0678dc004e7b1e159ad0 b/fuzz/corpus/alloc_ops/1d872b4d74787ef0d1ff0678dc004e7b1e159ad0 new file mode 100644 index 0000000..6038932 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1d872b4d74787ef0d1ff0678dc004e7b1e159ad0 differ diff --git a/fuzz/corpus/alloc_ops/1e054b8ac3e83998ed97c108d90c0f7cc4827751 b/fuzz/corpus/alloc_ops/1e054b8ac3e83998ed97c108d90c0f7cc4827751 new file mode 100644 index 0000000..7afe572 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1e054b8ac3e83998ed97c108d90c0f7cc4827751 differ diff --git a/fuzz/corpus/alloc_ops/1e1936b5c359b1487960586981a8125478a4b7a5 b/fuzz/corpus/alloc_ops/1e1936b5c359b1487960586981a8125478a4b7a5 new file mode 100644 index 0000000..7b26fca Binary files /dev/null and b/fuzz/corpus/alloc_ops/1e1936b5c359b1487960586981a8125478a4b7a5 differ diff --git a/fuzz/corpus/alloc_ops/1e7e0c34885455fbea0359185f3e9e7e25018a3c b/fuzz/corpus/alloc_ops/1e7e0c34885455fbea0359185f3e9e7e25018a3c new file mode 100644 index 0000000..8bb14db Binary files /dev/null and b/fuzz/corpus/alloc_ops/1e7e0c34885455fbea0359185f3e9e7e25018a3c differ diff --git a/fuzz/corpus/alloc_ops/1e86d13478bb57b721a02b635c4250994603749b b/fuzz/corpus/alloc_ops/1e86d13478bb57b721a02b635c4250994603749b new file mode 100644 index 0000000..1f5aa24 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1e86d13478bb57b721a02b635c4250994603749b differ diff --git a/fuzz/corpus/alloc_ops/1e9e166e7c16b31a1d30d735e792d02a608223ff b/fuzz/corpus/alloc_ops/1e9e166e7c16b31a1d30d735e792d02a608223ff new file mode 100644 index 0000000..f0707e2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1e9e166e7c16b31a1d30d735e792d02a608223ff differ diff --git a/fuzz/corpus/alloc_ops/1edf84530d929804030c0798c6aff3f7a258df1d b/fuzz/corpus/alloc_ops/1edf84530d929804030c0798c6aff3f7a258df1d new file mode 100644 index 0000000..0a4cd2d Binary files /dev/null and b/fuzz/corpus/alloc_ops/1edf84530d929804030c0798c6aff3f7a258df1d differ diff --git a/fuzz/corpus/alloc_ops/1ee1c8e5ad6b6bfb238ff23b1baee4b43b9c26c6 b/fuzz/corpus/alloc_ops/1ee1c8e5ad6b6bfb238ff23b1baee4b43b9c26c6 new file mode 100644 index 0000000..bb2839c --- /dev/null +++ b/fuzz/corpus/alloc_ops/1ee1c8e5ad6b6bfb238ff23b1baee4b43b9c26c6 @@ -0,0 +1 @@ +—h—@— \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/1f2fcb862b00726f519747744903f4e829e0061b b/fuzz/corpus/alloc_ops/1f2fcb862b00726f519747744903f4e829e0061b new file mode 100644 index 0000000..e3b26dd Binary files /dev/null and b/fuzz/corpus/alloc_ops/1f2fcb862b00726f519747744903f4e829e0061b differ diff --git a/fuzz/corpus/alloc_ops/1f5835cf95639552a131a7fd49c602792ff7aaff b/fuzz/corpus/alloc_ops/1f5835cf95639552a131a7fd49c602792ff7aaff new file mode 100644 index 0000000..dae2406 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1f5835cf95639552a131a7fd49c602792ff7aaff differ diff --git a/fuzz/corpus/alloc_ops/1fe0edab1dcd94df9f3ed72f8bcca5ed1e877d92 b/fuzz/corpus/alloc_ops/1fe0edab1dcd94df9f3ed72f8bcca5ed1e877d92 new file mode 100644 index 0000000..a4437b7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/1fe0edab1dcd94df9f3ed72f8bcca5ed1e877d92 differ diff --git a/fuzz/corpus/alloc_ops/205e6584514374d68aed43a03906c579877d40e8 b/fuzz/corpus/alloc_ops/205e6584514374d68aed43a03906c579877d40e8 new file mode 100644 index 0000000..716e499 Binary files /dev/null and b/fuzz/corpus/alloc_ops/205e6584514374d68aed43a03906c579877d40e8 differ diff --git a/fuzz/corpus/alloc_ops/207e7f4372a99c694f3b268eec0dfc8a42b082c7 b/fuzz/corpus/alloc_ops/207e7f4372a99c694f3b268eec0dfc8a42b082c7 new file mode 100644 index 0000000..7780c03 Binary files /dev/null and b/fuzz/corpus/alloc_ops/207e7f4372a99c694f3b268eec0dfc8a42b082c7 differ diff --git a/fuzz/corpus/alloc_ops/20957e16547e84f633b394dd2735a15ab7d601e6 b/fuzz/corpus/alloc_ops/20957e16547e84f633b394dd2735a15ab7d601e6 new file mode 100644 index 0000000..7c595b6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/20957e16547e84f633b394dd2735a15ab7d601e6 differ diff --git a/fuzz/corpus/alloc_ops/20ffcb23579c7fe89c12a5278d745892886ce0c8 b/fuzz/corpus/alloc_ops/20ffcb23579c7fe89c12a5278d745892886ce0c8 new file mode 100644 index 0000000..f9b41a7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/20ffcb23579c7fe89c12a5278d745892886ce0c8 differ diff --git a/fuzz/corpus/alloc_ops/210df15b5035ba779c85a30c1c911bd95c336773 b/fuzz/corpus/alloc_ops/210df15b5035ba779c85a30c1c911bd95c336773 new file mode 100644 index 0000000..4bccdce Binary files /dev/null and b/fuzz/corpus/alloc_ops/210df15b5035ba779c85a30c1c911bd95c336773 differ diff --git a/fuzz/corpus/alloc_ops/211a4a6914a494528a2a7a6d96cbf33279be90ab b/fuzz/corpus/alloc_ops/211a4a6914a494528a2a7a6d96cbf33279be90ab new file mode 100644 index 0000000..8defb2e Binary files /dev/null and b/fuzz/corpus/alloc_ops/211a4a6914a494528a2a7a6d96cbf33279be90ab differ diff --git a/fuzz/corpus/alloc_ops/214a7434bdd2bbf878367a76b5d25472418a44d0 b/fuzz/corpus/alloc_ops/214a7434bdd2bbf878367a76b5d25472418a44d0 new file mode 100644 index 0000000..fda182e Binary files /dev/null and b/fuzz/corpus/alloc_ops/214a7434bdd2bbf878367a76b5d25472418a44d0 differ diff --git a/fuzz/corpus/alloc_ops/21988da6a4984d4eb6b0a44405784af8e7f44804 b/fuzz/corpus/alloc_ops/21988da6a4984d4eb6b0a44405784af8e7f44804 new file mode 100644 index 0000000..0ed1156 Binary files /dev/null and b/fuzz/corpus/alloc_ops/21988da6a4984d4eb6b0a44405784af8e7f44804 differ diff --git a/fuzz/corpus/alloc_ops/219e1c63af15b8135336f0bbc30ce26d3b47a618 b/fuzz/corpus/alloc_ops/219e1c63af15b8135336f0bbc30ce26d3b47a618 new file mode 100644 index 0000000..bbab670 Binary files /dev/null and b/fuzz/corpus/alloc_ops/219e1c63af15b8135336f0bbc30ce26d3b47a618 differ diff --git a/fuzz/corpus/alloc_ops/21ca8ff5c89e332653e6e318e2202e611a30e749 b/fuzz/corpus/alloc_ops/21ca8ff5c89e332653e6e318e2202e611a30e749 new file mode 100644 index 0000000..b354539 Binary files /dev/null and b/fuzz/corpus/alloc_ops/21ca8ff5c89e332653e6e318e2202e611a30e749 differ diff --git a/fuzz/corpus/alloc_ops/21d1f149ee0163d3131d1ed8f2297373370f14c3 b/fuzz/corpus/alloc_ops/21d1f149ee0163d3131d1ed8f2297373370f14c3 new file mode 100644 index 0000000..445f5a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/21d1f149ee0163d3131d1ed8f2297373370f14c3 differ diff --git a/fuzz/corpus/alloc_ops/21e01bab4362e2159f23c4e5c0cb6fddaf610607 b/fuzz/corpus/alloc_ops/21e01bab4362e2159f23c4e5c0cb6fddaf610607 new file mode 100644 index 0000000..638265e Binary files /dev/null and b/fuzz/corpus/alloc_ops/21e01bab4362e2159f23c4e5c0cb6fddaf610607 differ diff --git a/fuzz/corpus/alloc_ops/21e6f560943a84e6a290ae6a7ffc412e7154fa30 b/fuzz/corpus/alloc_ops/21e6f560943a84e6a290ae6a7ffc412e7154fa30 new file mode 100644 index 0000000..42a9ac1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/21e6f560943a84e6a290ae6a7ffc412e7154fa30 differ diff --git a/fuzz/corpus/alloc_ops/21fa59f595c786c6f41cf540d1d19705b44ee616 b/fuzz/corpus/alloc_ops/21fa59f595c786c6f41cf540d1d19705b44ee616 new file mode 100644 index 0000000..0fcb649 Binary files /dev/null and b/fuzz/corpus/alloc_ops/21fa59f595c786c6f41cf540d1d19705b44ee616 differ diff --git a/fuzz/corpus/alloc_ops/220f7b5a65f5377ad5cb9966e8af46880b275c21 b/fuzz/corpus/alloc_ops/220f7b5a65f5377ad5cb9966e8af46880b275c21 new file mode 100644 index 0000000..e22bcf8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/220f7b5a65f5377ad5cb9966e8af46880b275c21 differ diff --git a/fuzz/corpus/alloc_ops/221c1ec1d337e170308468bdc047d615d4cd0387 b/fuzz/corpus/alloc_ops/221c1ec1d337e170308468bdc047d615d4cd0387 new file mode 100644 index 0000000..12ddd3b Binary files /dev/null and b/fuzz/corpus/alloc_ops/221c1ec1d337e170308468bdc047d615d4cd0387 differ diff --git a/fuzz/corpus/alloc_ops/221e7b9cfaafe24286bb4de09e01c5acab2e13d0 b/fuzz/corpus/alloc_ops/221e7b9cfaafe24286bb4de09e01c5acab2e13d0 new file mode 100644 index 0000000..7f215a0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/221e7b9cfaafe24286bb4de09e01c5acab2e13d0 differ diff --git a/fuzz/corpus/alloc_ops/22e1905ba2e8dd01aebf08b76c788da968656148 b/fuzz/corpus/alloc_ops/22e1905ba2e8dd01aebf08b76c788da968656148 new file mode 100644 index 0000000..6927755 Binary files /dev/null and b/fuzz/corpus/alloc_ops/22e1905ba2e8dd01aebf08b76c788da968656148 differ diff --git a/fuzz/corpus/alloc_ops/234fc2abf5bc00fd00354ef495290cacae6a01a9 b/fuzz/corpus/alloc_ops/234fc2abf5bc00fd00354ef495290cacae6a01a9 new file mode 100644 index 0000000..690d55a Binary files /dev/null and b/fuzz/corpus/alloc_ops/234fc2abf5bc00fd00354ef495290cacae6a01a9 differ diff --git a/fuzz/corpus/alloc_ops/2381ae9636b4ffea07d711361cd75fbd066db7dd b/fuzz/corpus/alloc_ops/2381ae9636b4ffea07d711361cd75fbd066db7dd new file mode 100644 index 0000000..10c3d9c Binary files /dev/null and b/fuzz/corpus/alloc_ops/2381ae9636b4ffea07d711361cd75fbd066db7dd differ diff --git a/fuzz/corpus/alloc_ops/23a23b99a808c6be72a6f64aee391e4b46278802 b/fuzz/corpus/alloc_ops/23a23b99a808c6be72a6f64aee391e4b46278802 new file mode 100644 index 0000000..2adcf5c Binary files /dev/null and b/fuzz/corpus/alloc_ops/23a23b99a808c6be72a6f64aee391e4b46278802 differ diff --git a/fuzz/corpus/alloc_ops/23a629749d97f86fd7dcc5728328adada6e6d077 b/fuzz/corpus/alloc_ops/23a629749d97f86fd7dcc5728328adada6e6d077 new file mode 100644 index 0000000..48ef142 Binary files /dev/null and b/fuzz/corpus/alloc_ops/23a629749d97f86fd7dcc5728328adada6e6d077 differ diff --git a/fuzz/corpus/alloc_ops/23b364f2abfbde5f6b8caa84abea430b46befc80 b/fuzz/corpus/alloc_ops/23b364f2abfbde5f6b8caa84abea430b46befc80 new file mode 100644 index 0000000..694c0d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/23b364f2abfbde5f6b8caa84abea430b46befc80 differ diff --git a/fuzz/corpus/alloc_ops/23cbe9ca20d9cbbac9748d3708cc0f3a2d833ba2 b/fuzz/corpus/alloc_ops/23cbe9ca20d9cbbac9748d3708cc0f3a2d833ba2 new file mode 100644 index 0000000..9b93ff8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/23cbe9ca20d9cbbac9748d3708cc0f3a2d833ba2 differ diff --git a/fuzz/corpus/alloc_ops/23d0b8c3f3e418cb6c77f5564e56f8c2f8f26aad b/fuzz/corpus/alloc_ops/23d0b8c3f3e418cb6c77f5564e56f8c2f8f26aad new file mode 100644 index 0000000..a39eca5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/23d0b8c3f3e418cb6c77f5564e56f8c2f8f26aad differ diff --git a/fuzz/corpus/alloc_ops/23fba5bdfc04e17dda2234c142be457c1c9d6074 b/fuzz/corpus/alloc_ops/23fba5bdfc04e17dda2234c142be457c1c9d6074 new file mode 100644 index 0000000..decf20a Binary files /dev/null and b/fuzz/corpus/alloc_ops/23fba5bdfc04e17dda2234c142be457c1c9d6074 differ diff --git a/fuzz/corpus/alloc_ops/24200754957221f830a9cd893de7e21f9a79a7a4 b/fuzz/corpus/alloc_ops/24200754957221f830a9cd893de7e21f9a79a7a4 new file mode 100644 index 0000000..cced70f Binary files /dev/null and b/fuzz/corpus/alloc_ops/24200754957221f830a9cd893de7e21f9a79a7a4 differ diff --git a/fuzz/corpus/alloc_ops/243a1edf5dd65d69842f74bb8f1be2a83e3c07aa b/fuzz/corpus/alloc_ops/243a1edf5dd65d69842f74bb8f1be2a83e3c07aa new file mode 100644 index 0000000..a4d6daa Binary files /dev/null and b/fuzz/corpus/alloc_ops/243a1edf5dd65d69842f74bb8f1be2a83e3c07aa differ diff --git a/fuzz/corpus/alloc_ops/24a522fe50643d5048cd1122c0d42591a42f92e6 b/fuzz/corpus/alloc_ops/24a522fe50643d5048cd1122c0d42591a42f92e6 new file mode 100644 index 0000000..28ea5a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/24a522fe50643d5048cd1122c0d42591a42f92e6 differ diff --git a/fuzz/corpus/alloc_ops/24df12fced7222827ae8c7ddb9e10240e0a866d2 b/fuzz/corpus/alloc_ops/24df12fced7222827ae8c7ddb9e10240e0a866d2 new file mode 100644 index 0000000..2156626 Binary files /dev/null and b/fuzz/corpus/alloc_ops/24df12fced7222827ae8c7ddb9e10240e0a866d2 differ diff --git a/fuzz/corpus/alloc_ops/24f03838d687ebffd46c96801ac0a70ee81bfb8a b/fuzz/corpus/alloc_ops/24f03838d687ebffd46c96801ac0a70ee81bfb8a new file mode 100644 index 0000000..eacd0d8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/24f03838d687ebffd46c96801ac0a70ee81bfb8a differ diff --git a/fuzz/corpus/alloc_ops/2518863ee04cf8b0941137c451232e515fc43674 b/fuzz/corpus/alloc_ops/2518863ee04cf8b0941137c451232e515fc43674 new file mode 100644 index 0000000..14734f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2518863ee04cf8b0941137c451232e515fc43674 differ diff --git a/fuzz/corpus/alloc_ops/252d279c990f20c5e10723d0c2c21bc55c5e02a6 b/fuzz/corpus/alloc_ops/252d279c990f20c5e10723d0c2c21bc55c5e02a6 new file mode 100644 index 0000000..cb90400 Binary files /dev/null and b/fuzz/corpus/alloc_ops/252d279c990f20c5e10723d0c2c21bc55c5e02a6 differ diff --git a/fuzz/corpus/alloc_ops/25441505b9abde10db2a33c5acda8c5283775e6d b/fuzz/corpus/alloc_ops/25441505b9abde10db2a33c5acda8c5283775e6d new file mode 100644 index 0000000..87ac1dd Binary files /dev/null and b/fuzz/corpus/alloc_ops/25441505b9abde10db2a33c5acda8c5283775e6d differ diff --git a/fuzz/corpus/alloc_ops/255461f1ace9d3d809ed331627247fe433a088a2 b/fuzz/corpus/alloc_ops/255461f1ace9d3d809ed331627247fe433a088a2 new file mode 100644 index 0000000..cb33e67 Binary files /dev/null and b/fuzz/corpus/alloc_ops/255461f1ace9d3d809ed331627247fe433a088a2 differ diff --git a/fuzz/corpus/alloc_ops/2556456fe7ecb62c2cc4f09292eec528f3757efa b/fuzz/corpus/alloc_ops/2556456fe7ecb62c2cc4f09292eec528f3757efa new file mode 100644 index 0000000..0a407d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2556456fe7ecb62c2cc4f09292eec528f3757efa differ diff --git a/fuzz/corpus/alloc_ops/256e17073975f04b3b21e899c089c4170cd050ee b/fuzz/corpus/alloc_ops/256e17073975f04b3b21e899c089c4170cd050ee new file mode 100644 index 0000000..0110c1d Binary files /dev/null and b/fuzz/corpus/alloc_ops/256e17073975f04b3b21e899c089c4170cd050ee differ diff --git a/fuzz/corpus/alloc_ops/25823b5f19e4210f8336f513aad20a1675ee1751 b/fuzz/corpus/alloc_ops/25823b5f19e4210f8336f513aad20a1675ee1751 new file mode 100644 index 0000000..b4742fc Binary files /dev/null and b/fuzz/corpus/alloc_ops/25823b5f19e4210f8336f513aad20a1675ee1751 differ diff --git a/fuzz/corpus/alloc_ops/25841cc4a232645ac647ad3bc4a9da5e60df89ec b/fuzz/corpus/alloc_ops/25841cc4a232645ac647ad3bc4a9da5e60df89ec new file mode 100644 index 0000000..496a434 Binary files /dev/null and b/fuzz/corpus/alloc_ops/25841cc4a232645ac647ad3bc4a9da5e60df89ec differ diff --git a/fuzz/corpus/alloc_ops/25896b35884f83da4debb8f6318b4b8762364698 b/fuzz/corpus/alloc_ops/25896b35884f83da4debb8f6318b4b8762364698 new file mode 100644 index 0000000..e82a1b0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/25896b35884f83da4debb8f6318b4b8762364698 differ diff --git a/fuzz/corpus/alloc_ops/25bf7f2bd494fe9117dcbdcbab8c5372e97392c1 b/fuzz/corpus/alloc_ops/25bf7f2bd494fe9117dcbdcbab8c5372e97392c1 new file mode 100644 index 0000000..a5f043a Binary files /dev/null and b/fuzz/corpus/alloc_ops/25bf7f2bd494fe9117dcbdcbab8c5372e97392c1 differ diff --git a/fuzz/corpus/alloc_ops/2613c511726df879c85c91d5c27a897ffcc37e88 b/fuzz/corpus/alloc_ops/2613c511726df879c85c91d5c27a897ffcc37e88 new file mode 100644 index 0000000..63bc7cf Binary files /dev/null and b/fuzz/corpus/alloc_ops/2613c511726df879c85c91d5c27a897ffcc37e88 differ diff --git a/fuzz/corpus/alloc_ops/261c72170d61391b86b6a2ab7de47224fc4da624 b/fuzz/corpus/alloc_ops/261c72170d61391b86b6a2ab7de47224fc4da624 new file mode 100644 index 0000000..88bf0ce Binary files /dev/null and b/fuzz/corpus/alloc_ops/261c72170d61391b86b6a2ab7de47224fc4da624 differ diff --git a/fuzz/corpus/alloc_ops/26416df8ed250f1001620b40106fa4fd5c61a20a b/fuzz/corpus/alloc_ops/26416df8ed250f1001620b40106fa4fd5c61a20a new file mode 100644 index 0000000..2018ed0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/26416df8ed250f1001620b40106fa4fd5c61a20a differ diff --git a/fuzz/corpus/alloc_ops/266bf264a2ec26bc909bd65ec280e829732cc4d0 b/fuzz/corpus/alloc_ops/266bf264a2ec26bc909bd65ec280e829732cc4d0 new file mode 100644 index 0000000..35bca35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/266bf264a2ec26bc909bd65ec280e829732cc4d0 differ diff --git a/fuzz/corpus/alloc_ops/2687631388bcc8c65b8af6ae3c2edb48caabbcdf b/fuzz/corpus/alloc_ops/2687631388bcc8c65b8af6ae3c2edb48caabbcdf new file mode 100644 index 0000000..0657190 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2687631388bcc8c65b8af6ae3c2edb48caabbcdf differ diff --git a/fuzz/corpus/alloc_ops/26c872b882c21026fa205596b33110ba13f7f38b b/fuzz/corpus/alloc_ops/26c872b882c21026fa205596b33110ba13f7f38b new file mode 100644 index 0000000..6e26b79 Binary files /dev/null and b/fuzz/corpus/alloc_ops/26c872b882c21026fa205596b33110ba13f7f38b differ diff --git a/fuzz/corpus/alloc_ops/2718026fd041ae0c29c7005a209844460913c84d b/fuzz/corpus/alloc_ops/2718026fd041ae0c29c7005a209844460913c84d new file mode 100644 index 0000000..72d2859 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2718026fd041ae0c29c7005a209844460913c84d differ diff --git a/fuzz/corpus/alloc_ops/27572154acd1ec65e94926087680f541a581d0c5 b/fuzz/corpus/alloc_ops/27572154acd1ec65e94926087680f541a581d0c5 new file mode 100644 index 0000000..5a98b71 Binary files /dev/null and b/fuzz/corpus/alloc_ops/27572154acd1ec65e94926087680f541a581d0c5 differ diff --git a/fuzz/corpus/alloc_ops/27d37adc2b1f34482811da4d505cc72937bcdb3e b/fuzz/corpus/alloc_ops/27d37adc2b1f34482811da4d505cc72937bcdb3e new file mode 100644 index 0000000..8dc8a86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/27d37adc2b1f34482811da4d505cc72937bcdb3e differ diff --git a/fuzz/corpus/alloc_ops/28236cfdedd8dbb134d7608762f30fa3ea5b9a11 b/fuzz/corpus/alloc_ops/28236cfdedd8dbb134d7608762f30fa3ea5b9a11 new file mode 100644 index 0000000..b55f7d3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/28236cfdedd8dbb134d7608762f30fa3ea5b9a11 differ diff --git a/fuzz/corpus/alloc_ops/283c44a66172ec1255e5135180d26e11872e21dd b/fuzz/corpus/alloc_ops/283c44a66172ec1255e5135180d26e11872e21dd new file mode 100644 index 0000000..d2515e8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/283c44a66172ec1255e5135180d26e11872e21dd differ diff --git a/fuzz/corpus/alloc_ops/28561df90250d1ba4149b4a561f8fbb6766f5f9d b/fuzz/corpus/alloc_ops/28561df90250d1ba4149b4a561f8fbb6766f5f9d new file mode 100644 index 0000000..5d8ae69 Binary files /dev/null and b/fuzz/corpus/alloc_ops/28561df90250d1ba4149b4a561f8fbb6766f5f9d differ diff --git a/fuzz/corpus/alloc_ops/2874e4b5f9fbca591a27de00e7a7d4cd6bb60035 b/fuzz/corpus/alloc_ops/2874e4b5f9fbca591a27de00e7a7d4cd6bb60035 new file mode 100644 index 0000000..4dc1406 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2874e4b5f9fbca591a27de00e7a7d4cd6bb60035 differ diff --git a/fuzz/corpus/alloc_ops/28b02eef80cd8008a987ab54c2a0db486a55f3e4 b/fuzz/corpus/alloc_ops/28b02eef80cd8008a987ab54c2a0db486a55f3e4 new file mode 100644 index 0000000..960eee0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/28b02eef80cd8008a987ab54c2a0db486a55f3e4 differ diff --git a/fuzz/corpus/alloc_ops/28ce68ec4d3f67b20e18a14a42e8b1366eac0090 b/fuzz/corpus/alloc_ops/28ce68ec4d3f67b20e18a14a42e8b1366eac0090 new file mode 100644 index 0000000..3a07ae6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/28ce68ec4d3f67b20e18a14a42e8b1366eac0090 differ diff --git a/fuzz/corpus/alloc_ops/28f82d419cd3a8e8ebe232646319d8dc6ae38bd8 b/fuzz/corpus/alloc_ops/28f82d419cd3a8e8ebe232646319d8dc6ae38bd8 new file mode 100644 index 0000000..753e351 Binary files /dev/null and b/fuzz/corpus/alloc_ops/28f82d419cd3a8e8ebe232646319d8dc6ae38bd8 differ diff --git a/fuzz/corpus/alloc_ops/2920fab7d984ec629540142603c544012566c1a3 b/fuzz/corpus/alloc_ops/2920fab7d984ec629540142603c544012566c1a3 new file mode 100644 index 0000000..5b5ca96 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2920fab7d984ec629540142603c544012566c1a3 differ diff --git a/fuzz/corpus/alloc_ops/293d5df8f05ff7ca17eb6f873d633cacd01af4bd b/fuzz/corpus/alloc_ops/293d5df8f05ff7ca17eb6f873d633cacd01af4bd new file mode 100644 index 0000000..ea34e97 Binary files /dev/null and b/fuzz/corpus/alloc_ops/293d5df8f05ff7ca17eb6f873d633cacd01af4bd differ diff --git a/fuzz/corpus/alloc_ops/2950329eb44a01f2e8829c119366f721ec166706 b/fuzz/corpus/alloc_ops/2950329eb44a01f2e8829c119366f721ec166706 new file mode 100644 index 0000000..204b47b Binary files /dev/null and b/fuzz/corpus/alloc_ops/2950329eb44a01f2e8829c119366f721ec166706 differ diff --git a/fuzz/corpus/alloc_ops/298862ce8c6436fd4ebefa15a1a9c716debd43cb b/fuzz/corpus/alloc_ops/298862ce8c6436fd4ebefa15a1a9c716debd43cb new file mode 100644 index 0000000..8fb18c4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/298862ce8c6436fd4ebefa15a1a9c716debd43cb differ diff --git a/fuzz/corpus/alloc_ops/29e965dcd5e2f746cc65fd8dd0b0c4e7ccc03949 b/fuzz/corpus/alloc_ops/29e965dcd5e2f746cc65fd8dd0b0c4e7ccc03949 new file mode 100644 index 0000000..c3dafab Binary files /dev/null and b/fuzz/corpus/alloc_ops/29e965dcd5e2f746cc65fd8dd0b0c4e7ccc03949 differ diff --git a/fuzz/corpus/alloc_ops/2ad5766cd1b00a83b43212ee9e6c39a0f73c4687 b/fuzz/corpus/alloc_ops/2ad5766cd1b00a83b43212ee9e6c39a0f73c4687 new file mode 100644 index 0000000..65a07d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2ad5766cd1b00a83b43212ee9e6c39a0f73c4687 differ diff --git a/fuzz/corpus/alloc_ops/2be5874efc1075bf247652de2aba75ec2558a51e b/fuzz/corpus/alloc_ops/2be5874efc1075bf247652de2aba75ec2558a51e new file mode 100644 index 0000000..babc47e Binary files /dev/null and b/fuzz/corpus/alloc_ops/2be5874efc1075bf247652de2aba75ec2558a51e differ diff --git a/fuzz/corpus/alloc_ops/2bef03408143d703c40a245cbb9ef1eafeca41b9 b/fuzz/corpus/alloc_ops/2bef03408143d703c40a245cbb9ef1eafeca41b9 new file mode 100644 index 0000000..7dab93c Binary files /dev/null and b/fuzz/corpus/alloc_ops/2bef03408143d703c40a245cbb9ef1eafeca41b9 differ diff --git a/fuzz/corpus/alloc_ops/2bfe1015097112027a3f5f1e5405289cc1ad0198 b/fuzz/corpus/alloc_ops/2bfe1015097112027a3f5f1e5405289cc1ad0198 new file mode 100644 index 0000000..ebab35d Binary files /dev/null and b/fuzz/corpus/alloc_ops/2bfe1015097112027a3f5f1e5405289cc1ad0198 differ diff --git a/fuzz/corpus/alloc_ops/2c52c0bc175025b740a8e16567c1eb43c1dc2868 b/fuzz/corpus/alloc_ops/2c52c0bc175025b740a8e16567c1eb43c1dc2868 new file mode 100644 index 0000000..27c56b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2c52c0bc175025b740a8e16567c1eb43c1dc2868 differ diff --git a/fuzz/corpus/alloc_ops/2c954c8f4d51336544f4206fa0fa406905902f8e b/fuzz/corpus/alloc_ops/2c954c8f4d51336544f4206fa0fa406905902f8e new file mode 100644 index 0000000..879d98c Binary files /dev/null and b/fuzz/corpus/alloc_ops/2c954c8f4d51336544f4206fa0fa406905902f8e differ diff --git a/fuzz/corpus/alloc_ops/2ce4010d537b0a4e31727ecb2325e68cbb3aab22 b/fuzz/corpus/alloc_ops/2ce4010d537b0a4e31727ecb2325e68cbb3aab22 new file mode 100644 index 0000000..23d2a37 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2ce4010d537b0a4e31727ecb2325e68cbb3aab22 differ diff --git a/fuzz/corpus/alloc_ops/2d038905f0ac08a47f72240a649dd8232690df37 b/fuzz/corpus/alloc_ops/2d038905f0ac08a47f72240a649dd8232690df37 new file mode 100644 index 0000000..b7a55e7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2d038905f0ac08a47f72240a649dd8232690df37 differ diff --git a/fuzz/corpus/alloc_ops/2d4ae7756a9cbb7bd2d4b1f228478194adf4260f b/fuzz/corpus/alloc_ops/2d4ae7756a9cbb7bd2d4b1f228478194adf4260f new file mode 100644 index 0000000..76f5a47 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2d4ae7756a9cbb7bd2d4b1f228478194adf4260f differ diff --git a/fuzz/corpus/alloc_ops/2d4ce8b7f2eee366a2d56aa1a31c292d31ffb5bc b/fuzz/corpus/alloc_ops/2d4ce8b7f2eee366a2d56aa1a31c292d31ffb5bc new file mode 100644 index 0000000..44afab4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2d4ce8b7f2eee366a2d56aa1a31c292d31ffb5bc differ diff --git a/fuzz/corpus/alloc_ops/2d84ab65434a8cedbfab7ce6c281e80390298189 b/fuzz/corpus/alloc_ops/2d84ab65434a8cedbfab7ce6c281e80390298189 new file mode 100644 index 0000000..c1b073a Binary files /dev/null and b/fuzz/corpus/alloc_ops/2d84ab65434a8cedbfab7ce6c281e80390298189 differ diff --git a/fuzz/corpus/alloc_ops/2dee921d67e78cf69d49ff88bf0659d5f6f4c5f4 b/fuzz/corpus/alloc_ops/2dee921d67e78cf69d49ff88bf0659d5f6f4c5f4 new file mode 100644 index 0000000..c6614fd Binary files /dev/null and b/fuzz/corpus/alloc_ops/2dee921d67e78cf69d49ff88bf0659d5f6f4c5f4 differ diff --git a/fuzz/corpus/alloc_ops/2df47d7258bf06d014303144f3817388d273ef6a b/fuzz/corpus/alloc_ops/2df47d7258bf06d014303144f3817388d273ef6a new file mode 100644 index 0000000..871536d Binary files /dev/null and b/fuzz/corpus/alloc_ops/2df47d7258bf06d014303144f3817388d273ef6a differ diff --git a/fuzz/corpus/alloc_ops/2e52fea26945f76ad78e014dd971a3cbb88b18c9 b/fuzz/corpus/alloc_ops/2e52fea26945f76ad78e014dd971a3cbb88b18c9 new file mode 100644 index 0000000..f474b6f Binary files /dev/null and b/fuzz/corpus/alloc_ops/2e52fea26945f76ad78e014dd971a3cbb88b18c9 differ diff --git a/fuzz/corpus/alloc_ops/2e845fca21bff610ee4b4e96731bd8ec87fe7fba b/fuzz/corpus/alloc_ops/2e845fca21bff610ee4b4e96731bd8ec87fe7fba new file mode 100644 index 0000000..3cbd40c Binary files /dev/null and b/fuzz/corpus/alloc_ops/2e845fca21bff610ee4b4e96731bd8ec87fe7fba differ diff --git a/fuzz/corpus/alloc_ops/2ea9be65b7291e83c48fd34613792a4fd486d04d b/fuzz/corpus/alloc_ops/2ea9be65b7291e83c48fd34613792a4fd486d04d new file mode 100644 index 0000000..a2b3e56 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2ea9be65b7291e83c48fd34613792a4fd486d04d differ diff --git a/fuzz/corpus/alloc_ops/2eec80393004c8829dd0f9c14d5efde48f41c95a b/fuzz/corpus/alloc_ops/2eec80393004c8829dd0f9c14d5efde48f41c95a new file mode 100644 index 0000000..c1e14ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/2eec80393004c8829dd0f9c14d5efde48f41c95a differ diff --git a/fuzz/corpus/alloc_ops/2ef00aa4881cd69b291bcaa6065e8f38e1cfa4c3 b/fuzz/corpus/alloc_ops/2ef00aa4881cd69b291bcaa6065e8f38e1cfa4c3 new file mode 100644 index 0000000..4e0daaf Binary files /dev/null and b/fuzz/corpus/alloc_ops/2ef00aa4881cd69b291bcaa6065e8f38e1cfa4c3 differ diff --git a/fuzz/corpus/alloc_ops/2efeb2b795e88d94a04a80f9442119cd93b74cc1 b/fuzz/corpus/alloc_ops/2efeb2b795e88d94a04a80f9442119cd93b74cc1 new file mode 100644 index 0000000..2b4e000 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2efeb2b795e88d94a04a80f9442119cd93b74cc1 differ diff --git a/fuzz/corpus/alloc_ops/2f0207de7b5a52834f47b70ebdfcdf9ba6208d0c b/fuzz/corpus/alloc_ops/2f0207de7b5a52834f47b70ebdfcdf9ba6208d0c new file mode 100644 index 0000000..1895cb3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f0207de7b5a52834f47b70ebdfcdf9ba6208d0c differ diff --git a/fuzz/corpus/alloc_ops/2f023bfef5a457edc910ac0ff19d99c0ba70c684 b/fuzz/corpus/alloc_ops/2f023bfef5a457edc910ac0ff19d99c0ba70c684 new file mode 100644 index 0000000..27637c8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f023bfef5a457edc910ac0ff19d99c0ba70c684 differ diff --git a/fuzz/corpus/alloc_ops/2f23af4c068069e941a8488c311affdd2fa93b1f b/fuzz/corpus/alloc_ops/2f23af4c068069e941a8488c311affdd2fa93b1f new file mode 100644 index 0000000..670e335 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f23af4c068069e941a8488c311affdd2fa93b1f differ diff --git a/fuzz/corpus/alloc_ops/2f37f9bb10a532faed3a12f1d8cde295cd1d57a2 b/fuzz/corpus/alloc_ops/2f37f9bb10a532faed3a12f1d8cde295cd1d57a2 new file mode 100644 index 0000000..77fc028 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f37f9bb10a532faed3a12f1d8cde295cd1d57a2 differ diff --git a/fuzz/corpus/alloc_ops/2f44e344a63e222bb6daaffa4c06c511e66a1700 b/fuzz/corpus/alloc_ops/2f44e344a63e222bb6daaffa4c06c511e66a1700 new file mode 100644 index 0000000..6984437 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f44e344a63e222bb6daaffa4c06c511e66a1700 differ diff --git a/fuzz/corpus/alloc_ops/2f89f70bb1c1ae1a745d1c8462fff1d44878d79f b/fuzz/corpus/alloc_ops/2f89f70bb1c1ae1a745d1c8462fff1d44878d79f new file mode 100644 index 0000000..45cc7a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f89f70bb1c1ae1a745d1c8462fff1d44878d79f differ diff --git a/fuzz/corpus/alloc_ops/2f9bb0e6e910b5822836468e2ccff5c256ee1b7c b/fuzz/corpus/alloc_ops/2f9bb0e6e910b5822836468e2ccff5c256ee1b7c new file mode 100644 index 0000000..b89c347 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2f9bb0e6e910b5822836468e2ccff5c256ee1b7c differ diff --git a/fuzz/corpus/alloc_ops/2fec8b76deca54505d935d980ceb453b1bafd0f1 b/fuzz/corpus/alloc_ops/2fec8b76deca54505d935d980ceb453b1bafd0f1 new file mode 100644 index 0000000..8656437 Binary files /dev/null and b/fuzz/corpus/alloc_ops/2fec8b76deca54505d935d980ceb453b1bafd0f1 differ diff --git a/fuzz/corpus/alloc_ops/301905fb04386917723f83dc0d2ac58fe7f9911c b/fuzz/corpus/alloc_ops/301905fb04386917723f83dc0d2ac58fe7f9911c new file mode 100644 index 0000000..f1dfda8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/301905fb04386917723f83dc0d2ac58fe7f9911c differ diff --git a/fuzz/corpus/alloc_ops/302f97cb0241fc94b28a536a622c53367731de15 b/fuzz/corpus/alloc_ops/302f97cb0241fc94b28a536a622c53367731de15 new file mode 100644 index 0000000..2c85535 Binary files /dev/null and b/fuzz/corpus/alloc_ops/302f97cb0241fc94b28a536a622c53367731de15 differ diff --git a/fuzz/corpus/alloc_ops/304fb4d587f0182a41e8b33358d3c0f455b59fce b/fuzz/corpus/alloc_ops/304fb4d587f0182a41e8b33358d3c0f455b59fce new file mode 100644 index 0000000..31140f6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/304fb4d587f0182a41e8b33358d3c0f455b59fce differ diff --git a/fuzz/corpus/alloc_ops/30961bf451298ea0dbbea37783dc75c5c6adf76e b/fuzz/corpus/alloc_ops/30961bf451298ea0dbbea37783dc75c5c6adf76e new file mode 100644 index 0000000..69f2e12 Binary files /dev/null and b/fuzz/corpus/alloc_ops/30961bf451298ea0dbbea37783dc75c5c6adf76e differ diff --git a/fuzz/corpus/alloc_ops/30be638902b7be2201c01537fe9f3523176ca2a8 b/fuzz/corpus/alloc_ops/30be638902b7be2201c01537fe9f3523176ca2a8 new file mode 100644 index 0000000..35d6cd0 --- /dev/null +++ b/fuzz/corpus/alloc_ops/30be638902b7be2201c01537fe9f3523176ca2a8 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/30c50f478e5a2bd092d8cf944f4d6022304ecb9d b/fuzz/corpus/alloc_ops/30c50f478e5a2bd092d8cf944f4d6022304ecb9d new file mode 100644 index 0000000..249d6d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/30c50f478e5a2bd092d8cf944f4d6022304ecb9d differ diff --git a/fuzz/corpus/alloc_ops/30f6e736999c2a655f3551859eceab9f5ef678b3 b/fuzz/corpus/alloc_ops/30f6e736999c2a655f3551859eceab9f5ef678b3 new file mode 100644 index 0000000..795ca46 Binary files /dev/null and b/fuzz/corpus/alloc_ops/30f6e736999c2a655f3551859eceab9f5ef678b3 differ diff --git a/fuzz/corpus/alloc_ops/31351d0ac29b76131e0d7f4d4dff53ee446d2a46 b/fuzz/corpus/alloc_ops/31351d0ac29b76131e0d7f4d4dff53ee446d2a46 new file mode 100644 index 0000000..ebe8a23 --- /dev/null +++ b/fuzz/corpus/alloc_ops/31351d0ac29b76131e0d7f4d4dff53ee446d2a46 @@ -0,0 +1 @@ +öÜ5ûß \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/31a520c3734a76625b82757a65760ee9766cb24c b/fuzz/corpus/alloc_ops/31a520c3734a76625b82757a65760ee9766cb24c new file mode 100644 index 0000000..7de04fb Binary files /dev/null and b/fuzz/corpus/alloc_ops/31a520c3734a76625b82757a65760ee9766cb24c differ diff --git a/fuzz/corpus/alloc_ops/31b378b89c7911822d324f4aab684ac857d72af2 b/fuzz/corpus/alloc_ops/31b378b89c7911822d324f4aab684ac857d72af2 new file mode 100644 index 0000000..78c46a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/31b378b89c7911822d324f4aab684ac857d72af2 differ diff --git a/fuzz/corpus/alloc_ops/31b520509685622660f82c2843b431847d51771c b/fuzz/corpus/alloc_ops/31b520509685622660f82c2843b431847d51771c new file mode 100644 index 0000000..a97bcb4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/31b520509685622660f82c2843b431847d51771c differ diff --git a/fuzz/corpus/alloc_ops/31bc3ab2d12a14efc250f574ba48957e79cd6397 b/fuzz/corpus/alloc_ops/31bc3ab2d12a14efc250f574ba48957e79cd6397 new file mode 100644 index 0000000..815c619 Binary files /dev/null and b/fuzz/corpus/alloc_ops/31bc3ab2d12a14efc250f574ba48957e79cd6397 differ diff --git a/fuzz/corpus/alloc_ops/320697675723294ea842a76facbf34cd5edd9ebf b/fuzz/corpus/alloc_ops/320697675723294ea842a76facbf34cd5edd9ebf new file mode 100644 index 0000000..9539dc7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/320697675723294ea842a76facbf34cd5edd9ebf differ diff --git a/fuzz/corpus/alloc_ops/3233f261251d1a9b1f357796c983d6ea8f1a2e43 b/fuzz/corpus/alloc_ops/3233f261251d1a9b1f357796c983d6ea8f1a2e43 new file mode 100644 index 0000000..0ae1bb6 --- /dev/null +++ b/fuzz/corpus/alloc_ops/3233f261251d1a9b1f357796c983d6ea8f1a2e43 @@ -0,0 +1 @@ +ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/329dfeef87925c0f7d973fc6c3a9504d1df37691 b/fuzz/corpus/alloc_ops/329dfeef87925c0f7d973fc6c3a9504d1df37691 new file mode 100644 index 0000000..521bcbf Binary files /dev/null and b/fuzz/corpus/alloc_ops/329dfeef87925c0f7d973fc6c3a9504d1df37691 differ diff --git a/fuzz/corpus/alloc_ops/32c1218c12ba756208182970dc2a1d79804c6274 b/fuzz/corpus/alloc_ops/32c1218c12ba756208182970dc2a1d79804c6274 new file mode 100644 index 0000000..71c0af7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/32c1218c12ba756208182970dc2a1d79804c6274 differ diff --git a/fuzz/corpus/alloc_ops/32e1b3d6e87c4f200bef43f568d5c9c56f42e691 b/fuzz/corpus/alloc_ops/32e1b3d6e87c4f200bef43f568d5c9c56f42e691 new file mode 100644 index 0000000..3468caf Binary files /dev/null and b/fuzz/corpus/alloc_ops/32e1b3d6e87c4f200bef43f568d5c9c56f42e691 differ diff --git a/fuzz/corpus/alloc_ops/331611ad16411c874e898c89f81a26ae86bf841f b/fuzz/corpus/alloc_ops/331611ad16411c874e898c89f81a26ae86bf841f new file mode 100644 index 0000000..9083834 Binary files /dev/null and b/fuzz/corpus/alloc_ops/331611ad16411c874e898c89f81a26ae86bf841f differ diff --git a/fuzz/corpus/alloc_ops/33312ac69f65e39debbe032fa05db8c90cd50038 b/fuzz/corpus/alloc_ops/33312ac69f65e39debbe032fa05db8c90cd50038 new file mode 100644 index 0000000..ae101bf --- /dev/null +++ b/fuzz/corpus/alloc_ops/33312ac69f65e39debbe032fa05db8c90cd50038 @@ -0,0 +1 @@ +« \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/334272949119b0dd45de4d4b1acafb09545740f5 b/fuzz/corpus/alloc_ops/334272949119b0dd45de4d4b1acafb09545740f5 new file mode 100644 index 0000000..3ffcbd1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/334272949119b0dd45de4d4b1acafb09545740f5 differ diff --git a/fuzz/corpus/alloc_ops/3347308a04a784e0a46af2e6dc3954f839e414f1 b/fuzz/corpus/alloc_ops/3347308a04a784e0a46af2e6dc3954f839e414f1 new file mode 100644 index 0000000..bff9df0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3347308a04a784e0a46af2e6dc3954f839e414f1 differ diff --git a/fuzz/corpus/alloc_ops/334a88532a05d2293010dc996e35ba2d220b690c b/fuzz/corpus/alloc_ops/334a88532a05d2293010dc996e35ba2d220b690c new file mode 100644 index 0000000..fce751a Binary files /dev/null and b/fuzz/corpus/alloc_ops/334a88532a05d2293010dc996e35ba2d220b690c differ diff --git a/fuzz/corpus/alloc_ops/3364306db8a4fc5e48165e862fb9376360826656 b/fuzz/corpus/alloc_ops/3364306db8a4fc5e48165e862fb9376360826656 new file mode 100644 index 0000000..be7066c Binary files /dev/null and b/fuzz/corpus/alloc_ops/3364306db8a4fc5e48165e862fb9376360826656 differ diff --git a/fuzz/corpus/alloc_ops/33e4e0b0635de098ab0654d6575a2efafa350e3c b/fuzz/corpus/alloc_ops/33e4e0b0635de098ab0654d6575a2efafa350e3c new file mode 100644 index 0000000..ae969fd Binary files /dev/null and b/fuzz/corpus/alloc_ops/33e4e0b0635de098ab0654d6575a2efafa350e3c differ diff --git a/fuzz/corpus/alloc_ops/33fa32dbcb22ec23120e21ab69c0a9e7def2ba83 b/fuzz/corpus/alloc_ops/33fa32dbcb22ec23120e21ab69c0a9e7def2ba83 new file mode 100644 index 0000000..ed8cdc8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/33fa32dbcb22ec23120e21ab69c0a9e7def2ba83 differ diff --git a/fuzz/corpus/alloc_ops/34530bf7c73028767edf66068be3e0cee204c94b b/fuzz/corpus/alloc_ops/34530bf7c73028767edf66068be3e0cee204c94b new file mode 100644 index 0000000..0624f18 Binary files /dev/null and b/fuzz/corpus/alloc_ops/34530bf7c73028767edf66068be3e0cee204c94b differ diff --git a/fuzz/corpus/alloc_ops/3461e4ca12849aadd38a7e6aa883bb34ea14f87a b/fuzz/corpus/alloc_ops/3461e4ca12849aadd38a7e6aa883bb34ea14f87a new file mode 100644 index 0000000..216144e Binary files /dev/null and b/fuzz/corpus/alloc_ops/3461e4ca12849aadd38a7e6aa883bb34ea14f87a differ diff --git a/fuzz/corpus/alloc_ops/348e209face3146c99b5c8e124fcf92f292ec37a b/fuzz/corpus/alloc_ops/348e209face3146c99b5c8e124fcf92f292ec37a new file mode 100644 index 0000000..f7c23e3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/348e209face3146c99b5c8e124fcf92f292ec37a differ diff --git a/fuzz/corpus/alloc_ops/34b39c799b81c874c58caeba53133c38c934aea0 b/fuzz/corpus/alloc_ops/34b39c799b81c874c58caeba53133c38c934aea0 new file mode 100644 index 0000000..e31f186 Binary files /dev/null and b/fuzz/corpus/alloc_ops/34b39c799b81c874c58caeba53133c38c934aea0 differ diff --git a/fuzz/corpus/alloc_ops/35bea9f9f068460c1b3706080598afe1ee9fffd2 b/fuzz/corpus/alloc_ops/35bea9f9f068460c1b3706080598afe1ee9fffd2 new file mode 100644 index 0000000..5a698bd Binary files /dev/null and b/fuzz/corpus/alloc_ops/35bea9f9f068460c1b3706080598afe1ee9fffd2 differ diff --git a/fuzz/corpus/alloc_ops/35fbc23db30e90deb62b7dfd6b7f594c541197a9 b/fuzz/corpus/alloc_ops/35fbc23db30e90deb62b7dfd6b7f594c541197a9 new file mode 100644 index 0000000..0b0a8d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/35fbc23db30e90deb62b7dfd6b7f594c541197a9 differ diff --git a/fuzz/corpus/alloc_ops/35fdb50821c401f480f712eb39791f40ddddfc09 b/fuzz/corpus/alloc_ops/35fdb50821c401f480f712eb39791f40ddddfc09 new file mode 100644 index 0000000..ca643bb Binary files /dev/null and b/fuzz/corpus/alloc_ops/35fdb50821c401f480f712eb39791f40ddddfc09 differ diff --git a/fuzz/corpus/alloc_ops/361024e912fab4cca272fd2c376586635682cf14 b/fuzz/corpus/alloc_ops/361024e912fab4cca272fd2c376586635682cf14 new file mode 100644 index 0000000..fc4692d Binary files /dev/null and b/fuzz/corpus/alloc_ops/361024e912fab4cca272fd2c376586635682cf14 differ diff --git a/fuzz/corpus/alloc_ops/3615b8aacbf7a59ea75d792a0b108b3c19c366c6 b/fuzz/corpus/alloc_ops/3615b8aacbf7a59ea75d792a0b108b3c19c366c6 new file mode 100644 index 0000000..4c2843c Binary files /dev/null and b/fuzz/corpus/alloc_ops/3615b8aacbf7a59ea75d792a0b108b3c19c366c6 differ diff --git a/fuzz/corpus/alloc_ops/36728247e4252dd57cec8d73d1371a8087416156 b/fuzz/corpus/alloc_ops/36728247e4252dd57cec8d73d1371a8087416156 new file mode 100644 index 0000000..ee20558 Binary files /dev/null and b/fuzz/corpus/alloc_ops/36728247e4252dd57cec8d73d1371a8087416156 differ diff --git a/fuzz/corpus/alloc_ops/367d260d650d9c07d68e3b5477f7ef20c5699144 b/fuzz/corpus/alloc_ops/367d260d650d9c07d68e3b5477f7ef20c5699144 new file mode 100644 index 0000000..04886d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/367d260d650d9c07d68e3b5477f7ef20c5699144 differ diff --git a/fuzz/corpus/alloc_ops/36d93ad22faaf9bd91476c5ba805153eafcbe5c1 b/fuzz/corpus/alloc_ops/36d93ad22faaf9bd91476c5ba805153eafcbe5c1 new file mode 100644 index 0000000..24a4cb9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/36d93ad22faaf9bd91476c5ba805153eafcbe5c1 differ diff --git a/fuzz/corpus/alloc_ops/36e2cf6c0db41d35c027b7b5655905baed11ec87 b/fuzz/corpus/alloc_ops/36e2cf6c0db41d35c027b7b5655905baed11ec87 new file mode 100644 index 0000000..bd36cfb Binary files /dev/null and b/fuzz/corpus/alloc_ops/36e2cf6c0db41d35c027b7b5655905baed11ec87 differ diff --git a/fuzz/corpus/alloc_ops/36f9d33c80f0ee65abb0ab09b80dbb148a20b3f5 b/fuzz/corpus/alloc_ops/36f9d33c80f0ee65abb0ab09b80dbb148a20b3f5 new file mode 100644 index 0000000..3923c1a Binary files /dev/null and b/fuzz/corpus/alloc_ops/36f9d33c80f0ee65abb0ab09b80dbb148a20b3f5 differ diff --git a/fuzz/corpus/alloc_ops/36fcb76f345cdd81bdf4a9ee7709a8e7d32ca47c b/fuzz/corpus/alloc_ops/36fcb76f345cdd81bdf4a9ee7709a8e7d32ca47c new file mode 100644 index 0000000..efb0531 Binary files /dev/null and b/fuzz/corpus/alloc_ops/36fcb76f345cdd81bdf4a9ee7709a8e7d32ca47c differ diff --git a/fuzz/corpus/alloc_ops/370c9ed67c9b869ddf87716f64b8f3090b715445 b/fuzz/corpus/alloc_ops/370c9ed67c9b869ddf87716f64b8f3090b715445 new file mode 100644 index 0000000..aa90597 Binary files /dev/null and b/fuzz/corpus/alloc_ops/370c9ed67c9b869ddf87716f64b8f3090b715445 differ diff --git a/fuzz/corpus/alloc_ops/372ba4c623f79bb73368e2e50ab08b7f033372aa b/fuzz/corpus/alloc_ops/372ba4c623f79bb73368e2e50ab08b7f033372aa new file mode 100644 index 0000000..e3a07f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/372ba4c623f79bb73368e2e50ab08b7f033372aa differ diff --git a/fuzz/corpus/alloc_ops/3760a82e62650515c648d897c6fd1f518a5e01fa b/fuzz/corpus/alloc_ops/3760a82e62650515c648d897c6fd1f518a5e01fa new file mode 100644 index 0000000..c1f87af Binary files /dev/null and b/fuzz/corpus/alloc_ops/3760a82e62650515c648d897c6fd1f518a5e01fa differ diff --git a/fuzz/corpus/alloc_ops/3789c6400dc6291d3a0a8685d59a35a1ef45b612 b/fuzz/corpus/alloc_ops/3789c6400dc6291d3a0a8685d59a35a1ef45b612 new file mode 100644 index 0000000..8345d74 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3789c6400dc6291d3a0a8685d59a35a1ef45b612 differ diff --git a/fuzz/corpus/alloc_ops/382a9ea8ce1947ef10de300733f693a081006fcd b/fuzz/corpus/alloc_ops/382a9ea8ce1947ef10de300733f693a081006fcd new file mode 100644 index 0000000..1fd4861 Binary files /dev/null and b/fuzz/corpus/alloc_ops/382a9ea8ce1947ef10de300733f693a081006fcd differ diff --git a/fuzz/corpus/alloc_ops/385548c4dba516de0690e40a1f50a14680578e97 b/fuzz/corpus/alloc_ops/385548c4dba516de0690e40a1f50a14680578e97 new file mode 100644 index 0000000..9518eaa Binary files /dev/null and b/fuzz/corpus/alloc_ops/385548c4dba516de0690e40a1f50a14680578e97 differ diff --git a/fuzz/corpus/alloc_ops/386b89a66bc1ab0f260fbe0f59299e2fe478320c b/fuzz/corpus/alloc_ops/386b89a66bc1ab0f260fbe0f59299e2fe478320c new file mode 100644 index 0000000..d06b9f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/386b89a66bc1ab0f260fbe0f59299e2fe478320c differ diff --git a/fuzz/corpus/alloc_ops/38adecf5c3297944d9ff408776e6fb7f4c8cc477 b/fuzz/corpus/alloc_ops/38adecf5c3297944d9ff408776e6fb7f4c8cc477 new file mode 100644 index 0000000..2b835aa Binary files /dev/null and b/fuzz/corpus/alloc_ops/38adecf5c3297944d9ff408776e6fb7f4c8cc477 differ diff --git a/fuzz/corpus/alloc_ops/38b4fb2d5211085128979dcf1243378778a1dec9 b/fuzz/corpus/alloc_ops/38b4fb2d5211085128979dcf1243378778a1dec9 new file mode 100644 index 0000000..0f79521 Binary files /dev/null and b/fuzz/corpus/alloc_ops/38b4fb2d5211085128979dcf1243378778a1dec9 differ diff --git a/fuzz/corpus/alloc_ops/38fa562089f85d6cbed052072a25ccaf0a9bd6e0 b/fuzz/corpus/alloc_ops/38fa562089f85d6cbed052072a25ccaf0a9bd6e0 new file mode 100644 index 0000000..355c922 Binary files /dev/null and b/fuzz/corpus/alloc_ops/38fa562089f85d6cbed052072a25ccaf0a9bd6e0 differ diff --git a/fuzz/corpus/alloc_ops/390a9a76fc4de5ab90a8f60537737c3a6c89b0db b/fuzz/corpus/alloc_ops/390a9a76fc4de5ab90a8f60537737c3a6c89b0db new file mode 100644 index 0000000..fef486c Binary files /dev/null and b/fuzz/corpus/alloc_ops/390a9a76fc4de5ab90a8f60537737c3a6c89b0db differ diff --git a/fuzz/corpus/alloc_ops/390d40d73d345a148b5499009f3de63ae05fd5ec b/fuzz/corpus/alloc_ops/390d40d73d345a148b5499009f3de63ae05fd5ec new file mode 100644 index 0000000..e251d63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/390d40d73d345a148b5499009f3de63ae05fd5ec differ diff --git a/fuzz/corpus/alloc_ops/3934edaaaff766dab9b77ecae4bb5be11447abad b/fuzz/corpus/alloc_ops/3934edaaaff766dab9b77ecae4bb5be11447abad new file mode 100644 index 0000000..eee59f0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3934edaaaff766dab9b77ecae4bb5be11447abad differ diff --git a/fuzz/corpus/alloc_ops/393ce08bacd10611fdf2024f677543c408b5c6d2 b/fuzz/corpus/alloc_ops/393ce08bacd10611fdf2024f677543c408b5c6d2 new file mode 100644 index 0000000..055af35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/393ce08bacd10611fdf2024f677543c408b5c6d2 differ diff --git a/fuzz/corpus/alloc_ops/394f55fd7a14fba02571ae47910af775205f0a48 b/fuzz/corpus/alloc_ops/394f55fd7a14fba02571ae47910af775205f0a48 new file mode 100644 index 0000000..de43745 Binary files /dev/null and b/fuzz/corpus/alloc_ops/394f55fd7a14fba02571ae47910af775205f0a48 differ diff --git a/fuzz/corpus/alloc_ops/398ac04601cbd68c74ee2bfc329edd36248de093 b/fuzz/corpus/alloc_ops/398ac04601cbd68c74ee2bfc329edd36248de093 new file mode 100644 index 0000000..8782785 Binary files /dev/null and b/fuzz/corpus/alloc_ops/398ac04601cbd68c74ee2bfc329edd36248de093 differ diff --git a/fuzz/corpus/alloc_ops/399cd882673574c4462500d844c074197cf1351d b/fuzz/corpus/alloc_ops/399cd882673574c4462500d844c074197cf1351d new file mode 100644 index 0000000..934de0b Binary files /dev/null and b/fuzz/corpus/alloc_ops/399cd882673574c4462500d844c074197cf1351d differ diff --git a/fuzz/corpus/alloc_ops/39eb3b1b3c933dcd1bf53f1365a89076f9f8e62b b/fuzz/corpus/alloc_ops/39eb3b1b3c933dcd1bf53f1365a89076f9f8e62b new file mode 100644 index 0000000..dda3f98 Binary files /dev/null and b/fuzz/corpus/alloc_ops/39eb3b1b3c933dcd1bf53f1365a89076f9f8e62b differ diff --git a/fuzz/corpus/alloc_ops/39f15ac5afb8e24c6a04092a3993d1e7d1793a76 b/fuzz/corpus/alloc_ops/39f15ac5afb8e24c6a04092a3993d1e7d1793a76 new file mode 100644 index 0000000..8da5791 Binary files /dev/null and b/fuzz/corpus/alloc_ops/39f15ac5afb8e24c6a04092a3993d1e7d1793a76 differ diff --git a/fuzz/corpus/alloc_ops/3a4edfa994a726b2241d6247b5ec93718d0f50e8 b/fuzz/corpus/alloc_ops/3a4edfa994a726b2241d6247b5ec93718d0f50e8 new file mode 100644 index 0000000..214adc9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3a4edfa994a726b2241d6247b5ec93718d0f50e8 differ diff --git a/fuzz/corpus/alloc_ops/3a8269ee6fe80e777b880f753ab02d01da725749 b/fuzz/corpus/alloc_ops/3a8269ee6fe80e777b880f753ab02d01da725749 new file mode 100644 index 0000000..3bb5e1d Binary files /dev/null and b/fuzz/corpus/alloc_ops/3a8269ee6fe80e777b880f753ab02d01da725749 differ diff --git a/fuzz/corpus/alloc_ops/3ac529a853d682e2e6f0a62e55c6e0a0241c5a6d b/fuzz/corpus/alloc_ops/3ac529a853d682e2e6f0a62e55c6e0a0241c5a6d new file mode 100644 index 0000000..de50dbd Binary files /dev/null and b/fuzz/corpus/alloc_ops/3ac529a853d682e2e6f0a62e55c6e0a0241c5a6d differ diff --git a/fuzz/corpus/alloc_ops/3ad640595a67274bc114a9c37b228b4c3daffe24 b/fuzz/corpus/alloc_ops/3ad640595a67274bc114a9c37b228b4c3daffe24 new file mode 100644 index 0000000..8cb9e30 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3ad640595a67274bc114a9c37b228b4c3daffe24 differ diff --git a/fuzz/corpus/alloc_ops/3afb99035d621578ee954d7658a9c377a6831483 b/fuzz/corpus/alloc_ops/3afb99035d621578ee954d7658a9c377a6831483 new file mode 100644 index 0000000..7cc6ffc Binary files /dev/null and b/fuzz/corpus/alloc_ops/3afb99035d621578ee954d7658a9c377a6831483 differ diff --git a/fuzz/corpus/alloc_ops/3b139f7bdf219b54a8dbb2f731fa9fefe40f75bf b/fuzz/corpus/alloc_ops/3b139f7bdf219b54a8dbb2f731fa9fefe40f75bf new file mode 100644 index 0000000..b976065 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3b139f7bdf219b54a8dbb2f731fa9fefe40f75bf differ diff --git a/fuzz/corpus/alloc_ops/3bafc6579049234ec2dcb8f0c6dc4e1a4af4114a b/fuzz/corpus/alloc_ops/3bafc6579049234ec2dcb8f0c6dc4e1a4af4114a new file mode 100644 index 0000000..353c049 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3bafc6579049234ec2dcb8f0c6dc4e1a4af4114a differ diff --git a/fuzz/corpus/alloc_ops/3bcbe79b8ef41ed935fb41a2d7cf04a11aeb002c b/fuzz/corpus/alloc_ops/3bcbe79b8ef41ed935fb41a2d7cf04a11aeb002c new file mode 100644 index 0000000..b5cd9cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/3bcbe79b8ef41ed935fb41a2d7cf04a11aeb002c differ diff --git a/fuzz/corpus/alloc_ops/3bd8be947fdae884c769539addc3e9e3f4de006d b/fuzz/corpus/alloc_ops/3bd8be947fdae884c769539addc3e9e3f4de006d new file mode 100644 index 0000000..f339e76 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3bd8be947fdae884c769539addc3e9e3f4de006d differ diff --git a/fuzz/corpus/alloc_ops/3be57d6c51e96379cd5f81ee6355f28571c5adcc b/fuzz/corpus/alloc_ops/3be57d6c51e96379cd5f81ee6355f28571c5adcc new file mode 100644 index 0000000..8ecec8a --- /dev/null +++ b/fuzz/corpus/alloc_ops/3be57d6c51e96379cd5f81ee6355f28571c5adcc @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/3bed51efc1b54c68c8d5643ea14554b44f70463d b/fuzz/corpus/alloc_ops/3bed51efc1b54c68c8d5643ea14554b44f70463d new file mode 100644 index 0000000..5a4f86a Binary files /dev/null and b/fuzz/corpus/alloc_ops/3bed51efc1b54c68c8d5643ea14554b44f70463d differ diff --git a/fuzz/corpus/alloc_ops/3c13de92fd3d64971eb9e28571e2f972f7ce838b b/fuzz/corpus/alloc_ops/3c13de92fd3d64971eb9e28571e2f972f7ce838b new file mode 100644 index 0000000..d6ef53b Binary files /dev/null and b/fuzz/corpus/alloc_ops/3c13de92fd3d64971eb9e28571e2f972f7ce838b differ diff --git a/fuzz/corpus/alloc_ops/3c22c48ed342a05964ea059c3a76ec5797b8bc5d b/fuzz/corpus/alloc_ops/3c22c48ed342a05964ea059c3a76ec5797b8bc5d new file mode 100644 index 0000000..4c88075 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3c22c48ed342a05964ea059c3a76ec5797b8bc5d differ diff --git a/fuzz/corpus/alloc_ops/3ce0a1af90b6e7a3dd8d45e410884b588ea2d04c b/fuzz/corpus/alloc_ops/3ce0a1af90b6e7a3dd8d45e410884b588ea2d04c new file mode 100644 index 0000000..2a2a526 --- /dev/null +++ b/fuzz/corpus/alloc_ops/3ce0a1af90b6e7a3dd8d45e410884b588ea2d04c @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/3d01fb063bc0fbfb608956d52de89ec5b5140fc9 b/fuzz/corpus/alloc_ops/3d01fb063bc0fbfb608956d52de89ec5b5140fc9 new file mode 100644 index 0000000..d606ccd Binary files /dev/null and b/fuzz/corpus/alloc_ops/3d01fb063bc0fbfb608956d52de89ec5b5140fc9 differ diff --git a/fuzz/corpus/alloc_ops/3d047b01f2c122cb6d0363a26ec725c488be13c9 b/fuzz/corpus/alloc_ops/3d047b01f2c122cb6d0363a26ec725c488be13c9 new file mode 100644 index 0000000..32528f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3d047b01f2c122cb6d0363a26ec725c488be13c9 differ diff --git a/fuzz/corpus/alloc_ops/3d7087137c406cbcc35cfebb07bee142297d6a32 b/fuzz/corpus/alloc_ops/3d7087137c406cbcc35cfebb07bee142297d6a32 new file mode 100644 index 0000000..77bbfdc Binary files /dev/null and b/fuzz/corpus/alloc_ops/3d7087137c406cbcc35cfebb07bee142297d6a32 differ diff --git a/fuzz/corpus/alloc_ops/3d8c4f5af8bc2c742d163c7b4dfb71139d48415e b/fuzz/corpus/alloc_ops/3d8c4f5af8bc2c742d163c7b4dfb71139d48415e new file mode 100644 index 0000000..d5ebb99 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3d8c4f5af8bc2c742d163c7b4dfb71139d48415e differ diff --git a/fuzz/corpus/alloc_ops/3df4ecbf06c9d404ff2026fcc7b48507399799e2 b/fuzz/corpus/alloc_ops/3df4ecbf06c9d404ff2026fcc7b48507399799e2 new file mode 100644 index 0000000..29ca0ae Binary files /dev/null and b/fuzz/corpus/alloc_ops/3df4ecbf06c9d404ff2026fcc7b48507399799e2 differ diff --git a/fuzz/corpus/alloc_ops/3df595a28c53158a62b9ef14b1c78b9715607d7a b/fuzz/corpus/alloc_ops/3df595a28c53158a62b9ef14b1c78b9715607d7a new file mode 100644 index 0000000..200a090 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3df595a28c53158a62b9ef14b1c78b9715607d7a differ diff --git a/fuzz/corpus/alloc_ops/3e5f0426d438cae57577f1200314c1c6844f2930 b/fuzz/corpus/alloc_ops/3e5f0426d438cae57577f1200314c1c6844f2930 new file mode 100644 index 0000000..c994ee8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3e5f0426d438cae57577f1200314c1c6844f2930 differ diff --git a/fuzz/corpus/alloc_ops/3e6d2b80a6408b1da820812695bf07e2a7d23b63 b/fuzz/corpus/alloc_ops/3e6d2b80a6408b1da820812695bf07e2a7d23b63 new file mode 100644 index 0000000..1078e86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3e6d2b80a6408b1da820812695bf07e2a7d23b63 differ diff --git a/fuzz/corpus/alloc_ops/3e99f3d40107f207b853b04a8c82eb3087fc6fb5 b/fuzz/corpus/alloc_ops/3e99f3d40107f207b853b04a8c82eb3087fc6fb5 new file mode 100644 index 0000000..0d59c08 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3e99f3d40107f207b853b04a8c82eb3087fc6fb5 differ diff --git a/fuzz/corpus/alloc_ops/3ed7b845269854e52fb023b347902518263b3ac1 b/fuzz/corpus/alloc_ops/3ed7b845269854e52fb023b347902518263b3ac1 new file mode 100644 index 0000000..852d705 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3ed7b845269854e52fb023b347902518263b3ac1 differ diff --git a/fuzz/corpus/alloc_ops/3edb06a0acb22ec32b8d18ab7ff9c79c3e999082 b/fuzz/corpus/alloc_ops/3edb06a0acb22ec32b8d18ab7ff9c79c3e999082 new file mode 100644 index 0000000..d14ea15 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3edb06a0acb22ec32b8d18ab7ff9c79c3e999082 differ diff --git a/fuzz/corpus/alloc_ops/3f3e9455ebd613a29463e108e3594b90bb850cac b/fuzz/corpus/alloc_ops/3f3e9455ebd613a29463e108e3594b90bb850cac new file mode 100644 index 0000000..08445e2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3f3e9455ebd613a29463e108e3594b90bb850cac differ diff --git a/fuzz/corpus/alloc_ops/3f6e9b029b54aa5ff2047553fd9d357abc75cb6e b/fuzz/corpus/alloc_ops/3f6e9b029b54aa5ff2047553fd9d357abc75cb6e new file mode 100644 index 0000000..dc14f86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3f6e9b029b54aa5ff2047553fd9d357abc75cb6e differ diff --git a/fuzz/corpus/alloc_ops/3fa4527e47b209717af4f294ed997aa77b8886b7 b/fuzz/corpus/alloc_ops/3fa4527e47b209717af4f294ed997aa77b8886b7 new file mode 100644 index 0000000..4fc6c64 Binary files /dev/null and b/fuzz/corpus/alloc_ops/3fa4527e47b209717af4f294ed997aa77b8886b7 differ diff --git a/fuzz/corpus/alloc_ops/403ee689d1d24dc5609b7b9a26b536125cbca9e1 b/fuzz/corpus/alloc_ops/403ee689d1d24dc5609b7b9a26b536125cbca9e1 new file mode 100644 index 0000000..2c6dcee Binary files /dev/null and b/fuzz/corpus/alloc_ops/403ee689d1d24dc5609b7b9a26b536125cbca9e1 differ diff --git a/fuzz/corpus/alloc_ops/404ba27d0ea37fac50aec2c408d5330ffaabdca9 b/fuzz/corpus/alloc_ops/404ba27d0ea37fac50aec2c408d5330ffaabdca9 new file mode 100644 index 0000000..2151d7e Binary files /dev/null and b/fuzz/corpus/alloc_ops/404ba27d0ea37fac50aec2c408d5330ffaabdca9 differ diff --git a/fuzz/corpus/alloc_ops/4059b75ab7f6247423806526dbe1d46be8af7729 b/fuzz/corpus/alloc_ops/4059b75ab7f6247423806526dbe1d46be8af7729 new file mode 100644 index 0000000..30386e3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4059b75ab7f6247423806526dbe1d46be8af7729 differ diff --git a/fuzz/corpus/alloc_ops/405bf24a4bac3a265dde5b3696269d4df5f4b2d3 b/fuzz/corpus/alloc_ops/405bf24a4bac3a265dde5b3696269d4df5f4b2d3 new file mode 100644 index 0000000..bd32619 Binary files /dev/null and b/fuzz/corpus/alloc_ops/405bf24a4bac3a265dde5b3696269d4df5f4b2d3 differ diff --git a/fuzz/corpus/alloc_ops/407c0f8402ef8864c6a1188d239297d214b3fd4f b/fuzz/corpus/alloc_ops/407c0f8402ef8864c6a1188d239297d214b3fd4f new file mode 100644 index 0000000..7e46f5b Binary files /dev/null and b/fuzz/corpus/alloc_ops/407c0f8402ef8864c6a1188d239297d214b3fd4f differ diff --git a/fuzz/corpus/alloc_ops/40baaccf605786d276cecdfa2da45c4d4a3fbc7c b/fuzz/corpus/alloc_ops/40baaccf605786d276cecdfa2da45c4d4a3fbc7c new file mode 100644 index 0000000..c0c7850 Binary files /dev/null and b/fuzz/corpus/alloc_ops/40baaccf605786d276cecdfa2da45c4d4a3fbc7c differ diff --git a/fuzz/corpus/alloc_ops/40d40290eda44b4c23738787305052d66cc90dba b/fuzz/corpus/alloc_ops/40d40290eda44b4c23738787305052d66cc90dba new file mode 100644 index 0000000..6e1af35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/40d40290eda44b4c23738787305052d66cc90dba differ diff --git a/fuzz/corpus/alloc_ops/40e8362a5743aa20833f639269f050f260b1196d b/fuzz/corpus/alloc_ops/40e8362a5743aa20833f639269f050f260b1196d new file mode 100644 index 0000000..e08038d Binary files /dev/null and b/fuzz/corpus/alloc_ops/40e8362a5743aa20833f639269f050f260b1196d differ diff --git a/fuzz/corpus/alloc_ops/40f1f601a0a0ffbf4b7b6176c988eba381231085 b/fuzz/corpus/alloc_ops/40f1f601a0a0ffbf4b7b6176c988eba381231085 new file mode 100644 index 0000000..e10e167 Binary files /dev/null and b/fuzz/corpus/alloc_ops/40f1f601a0a0ffbf4b7b6176c988eba381231085 differ diff --git a/fuzz/corpus/alloc_ops/412d82ec09cffed8cd7607b848bfcc573a48655d b/fuzz/corpus/alloc_ops/412d82ec09cffed8cd7607b848bfcc573a48655d new file mode 100644 index 0000000..652bab2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/412d82ec09cffed8cd7607b848bfcc573a48655d differ diff --git a/fuzz/corpus/alloc_ops/416390915cbe296a4696db7f79e035b5bda6d2fd b/fuzz/corpus/alloc_ops/416390915cbe296a4696db7f79e035b5bda6d2fd new file mode 100644 index 0000000..a317dff Binary files /dev/null and b/fuzz/corpus/alloc_ops/416390915cbe296a4696db7f79e035b5bda6d2fd differ diff --git a/fuzz/corpus/alloc_ops/41839ed16fc9a382fd7de5fb1689f169e8696303 b/fuzz/corpus/alloc_ops/41839ed16fc9a382fd7de5fb1689f169e8696303 new file mode 100644 index 0000000..64304d8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/41839ed16fc9a382fd7de5fb1689f169e8696303 differ diff --git a/fuzz/corpus/alloc_ops/418ae166d4ee89fa4e7e533f46228d297b0cc8c0 b/fuzz/corpus/alloc_ops/418ae166d4ee89fa4e7e533f46228d297b0cc8c0 new file mode 100644 index 0000000..acdcd73 Binary files /dev/null and b/fuzz/corpus/alloc_ops/418ae166d4ee89fa4e7e533f46228d297b0cc8c0 differ diff --git a/fuzz/corpus/alloc_ops/41ba429b1f9190d97548ae6cc2f4c5fa38d82346 b/fuzz/corpus/alloc_ops/41ba429b1f9190d97548ae6cc2f4c5fa38d82346 new file mode 100644 index 0000000..8277db6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/41ba429b1f9190d97548ae6cc2f4c5fa38d82346 differ diff --git a/fuzz/corpus/alloc_ops/41fe10bcfdf7f91349a6d6e4f42425e0c784acc6 b/fuzz/corpus/alloc_ops/41fe10bcfdf7f91349a6d6e4f42425e0c784acc6 new file mode 100644 index 0000000..efb6003 Binary files /dev/null and b/fuzz/corpus/alloc_ops/41fe10bcfdf7f91349a6d6e4f42425e0c784acc6 differ diff --git a/fuzz/corpus/alloc_ops/41ffc3283fc1d2c425e9ab32005f053a49d2b287 b/fuzz/corpus/alloc_ops/41ffc3283fc1d2c425e9ab32005f053a49d2b287 new file mode 100644 index 0000000..1b1827c Binary files /dev/null and b/fuzz/corpus/alloc_ops/41ffc3283fc1d2c425e9ab32005f053a49d2b287 differ diff --git a/fuzz/corpus/alloc_ops/4220c2cfa08e4c616b563ba10ec8db66f7218ec5 b/fuzz/corpus/alloc_ops/4220c2cfa08e4c616b563ba10ec8db66f7218ec5 new file mode 100644 index 0000000..faed98c Binary files /dev/null and b/fuzz/corpus/alloc_ops/4220c2cfa08e4c616b563ba10ec8db66f7218ec5 differ diff --git a/fuzz/corpus/alloc_ops/4237cb3bdb3dd98c1c91987c1d1f0b8c7c03f4d6 b/fuzz/corpus/alloc_ops/4237cb3bdb3dd98c1c91987c1d1f0b8c7c03f4d6 new file mode 100644 index 0000000..96a994b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4237cb3bdb3dd98c1c91987c1d1f0b8c7c03f4d6 differ diff --git a/fuzz/corpus/alloc_ops/4243f95d936ac83086bda50605160f363c2f6bd4 b/fuzz/corpus/alloc_ops/4243f95d936ac83086bda50605160f363c2f6bd4 new file mode 100644 index 0000000..3c6d914 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4243f95d936ac83086bda50605160f363c2f6bd4 differ diff --git a/fuzz/corpus/alloc_ops/424ea455a5aee16727d20dcd985ae5e6623bebc4 b/fuzz/corpus/alloc_ops/424ea455a5aee16727d20dcd985ae5e6623bebc4 new file mode 100644 index 0000000..491f7a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/424ea455a5aee16727d20dcd985ae5e6623bebc4 differ diff --git a/fuzz/corpus/alloc_ops/42c7c29fde68d971845a1513629cb19336ecd61d b/fuzz/corpus/alloc_ops/42c7c29fde68d971845a1513629cb19336ecd61d new file mode 100644 index 0000000..217d269 Binary files /dev/null and b/fuzz/corpus/alloc_ops/42c7c29fde68d971845a1513629cb19336ecd61d differ diff --git a/fuzz/corpus/alloc_ops/42e257432e17eabd629f1f944a85162bddd9f97a b/fuzz/corpus/alloc_ops/42e257432e17eabd629f1f944a85162bddd9f97a new file mode 100644 index 0000000..dd3e244 Binary files /dev/null and b/fuzz/corpus/alloc_ops/42e257432e17eabd629f1f944a85162bddd9f97a differ diff --git a/fuzz/corpus/alloc_ops/432442e5a9413e5ba8475d7ba8233ade4d1927b3 b/fuzz/corpus/alloc_ops/432442e5a9413e5ba8475d7ba8233ade4d1927b3 new file mode 100644 index 0000000..f461ac9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/432442e5a9413e5ba8475d7ba8233ade4d1927b3 differ diff --git a/fuzz/corpus/alloc_ops/432cbebc55a062a9e97ed2a314d8010fec44c73f b/fuzz/corpus/alloc_ops/432cbebc55a062a9e97ed2a314d8010fec44c73f new file mode 100644 index 0000000..f387a9d Binary files /dev/null and b/fuzz/corpus/alloc_ops/432cbebc55a062a9e97ed2a314d8010fec44c73f differ diff --git a/fuzz/corpus/alloc_ops/4334cb909551f5d876750a51c4be6ef3dbb1e713 b/fuzz/corpus/alloc_ops/4334cb909551f5d876750a51c4be6ef3dbb1e713 new file mode 100644 index 0000000..35d9c6a Binary files /dev/null and b/fuzz/corpus/alloc_ops/4334cb909551f5d876750a51c4be6ef3dbb1e713 differ diff --git a/fuzz/corpus/alloc_ops/43c3432a1fd963f2f5a7a82bc7babc292d79cdd2 b/fuzz/corpus/alloc_ops/43c3432a1fd963f2f5a7a82bc7babc292d79cdd2 new file mode 100644 index 0000000..b516c43 Binary files /dev/null and b/fuzz/corpus/alloc_ops/43c3432a1fd963f2f5a7a82bc7babc292d79cdd2 differ diff --git a/fuzz/corpus/alloc_ops/43ec516436a1cca22a96d1d38cbbe5e0b3f9c6cf b/fuzz/corpus/alloc_ops/43ec516436a1cca22a96d1d38cbbe5e0b3f9c6cf new file mode 100644 index 0000000..9acd98e Binary files /dev/null and b/fuzz/corpus/alloc_ops/43ec516436a1cca22a96d1d38cbbe5e0b3f9c6cf differ diff --git a/fuzz/corpus/alloc_ops/4400746f1636f71a274ede1bba8a258ac47a2c61 b/fuzz/corpus/alloc_ops/4400746f1636f71a274ede1bba8a258ac47a2c61 new file mode 100644 index 0000000..868ff09 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4400746f1636f71a274ede1bba8a258ac47a2c61 differ diff --git a/fuzz/corpus/alloc_ops/448c8671fd357cfbec1679bc84f9dfd9cdf49c93 b/fuzz/corpus/alloc_ops/448c8671fd357cfbec1679bc84f9dfd9cdf49c93 new file mode 100644 index 0000000..68c063a Binary files /dev/null and b/fuzz/corpus/alloc_ops/448c8671fd357cfbec1679bc84f9dfd9cdf49c93 differ diff --git a/fuzz/corpus/alloc_ops/44b44774be6e3f1882e9c3832b39c3c463467687 b/fuzz/corpus/alloc_ops/44b44774be6e3f1882e9c3832b39c3c463467687 new file mode 100644 index 0000000..8d6bafe Binary files /dev/null and b/fuzz/corpus/alloc_ops/44b44774be6e3f1882e9c3832b39c3c463467687 differ diff --git a/fuzz/corpus/alloc_ops/44b50392edb38a79c79411e4bb5610c08b0bed85 b/fuzz/corpus/alloc_ops/44b50392edb38a79c79411e4bb5610c08b0bed85 new file mode 100644 index 0000000..2c13e77 Binary files /dev/null and b/fuzz/corpus/alloc_ops/44b50392edb38a79c79411e4bb5610c08b0bed85 differ diff --git a/fuzz/corpus/alloc_ops/44d27430084f9a656f7d3f2aba8b6d5b0b016719 b/fuzz/corpus/alloc_ops/44d27430084f9a656f7d3f2aba8b6d5b0b016719 new file mode 100644 index 0000000..7f263cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/44d27430084f9a656f7d3f2aba8b6d5b0b016719 differ diff --git a/fuzz/corpus/alloc_ops/44d7c3160a0c859cf8ad6fa87907fb214a53ac03 b/fuzz/corpus/alloc_ops/44d7c3160a0c859cf8ad6fa87907fb214a53ac03 new file mode 100644 index 0000000..8ef5e63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/44d7c3160a0c859cf8ad6fa87907fb214a53ac03 differ diff --git a/fuzz/corpus/alloc_ops/4512d6898bbb3df350551fc58181b7aa2e7e9972 b/fuzz/corpus/alloc_ops/4512d6898bbb3df350551fc58181b7aa2e7e9972 new file mode 100644 index 0000000..03e423c Binary files /dev/null and b/fuzz/corpus/alloc_ops/4512d6898bbb3df350551fc58181b7aa2e7e9972 differ diff --git a/fuzz/corpus/alloc_ops/453525923a4241e27ad7988dd0040ae09171c70c b/fuzz/corpus/alloc_ops/453525923a4241e27ad7988dd0040ae09171c70c new file mode 100644 index 0000000..f103c4a Binary files /dev/null and b/fuzz/corpus/alloc_ops/453525923a4241e27ad7988dd0040ae09171c70c differ diff --git a/fuzz/corpus/alloc_ops/456d17d945a411c263e2ef4201f29a9178eb6c98 b/fuzz/corpus/alloc_ops/456d17d945a411c263e2ef4201f29a9178eb6c98 new file mode 100644 index 0000000..04fbdc9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/456d17d945a411c263e2ef4201f29a9178eb6c98 differ diff --git a/fuzz/corpus/alloc_ops/458fc4c3539bb6e1b210b0a31ea0e090ffe8f2c6 b/fuzz/corpus/alloc_ops/458fc4c3539bb6e1b210b0a31ea0e090ffe8f2c6 new file mode 100644 index 0000000..c7dd032 Binary files /dev/null and b/fuzz/corpus/alloc_ops/458fc4c3539bb6e1b210b0a31ea0e090ffe8f2c6 differ diff --git a/fuzz/corpus/alloc_ops/459b68df3dbbd6fde865bdefa6d0ae58627e2ddd b/fuzz/corpus/alloc_ops/459b68df3dbbd6fde865bdefa6d0ae58627e2ddd new file mode 100644 index 0000000..5a0dde8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/459b68df3dbbd6fde865bdefa6d0ae58627e2ddd differ diff --git a/fuzz/corpus/alloc_ops/45a227b7d082c3cc0e2a43c539385d52e41b1446 b/fuzz/corpus/alloc_ops/45a227b7d082c3cc0e2a43c539385d52e41b1446 new file mode 100644 index 0000000..07bb043 Binary files /dev/null and b/fuzz/corpus/alloc_ops/45a227b7d082c3cc0e2a43c539385d52e41b1446 differ diff --git a/fuzz/corpus/alloc_ops/45a6bd7699a98ec36d624fcfcc374478b392174e b/fuzz/corpus/alloc_ops/45a6bd7699a98ec36d624fcfcc374478b392174e new file mode 100644 index 0000000..8d25e48 Binary files /dev/null and b/fuzz/corpus/alloc_ops/45a6bd7699a98ec36d624fcfcc374478b392174e differ diff --git a/fuzz/corpus/alloc_ops/45aa8103605867759aff1faa7f0af52358f92b6a b/fuzz/corpus/alloc_ops/45aa8103605867759aff1faa7f0af52358f92b6a new file mode 100644 index 0000000..9d6ccaa Binary files /dev/null and b/fuzz/corpus/alloc_ops/45aa8103605867759aff1faa7f0af52358f92b6a differ diff --git a/fuzz/corpus/alloc_ops/45ad8938255edacd16c17fb0622593baa76c8ca8 b/fuzz/corpus/alloc_ops/45ad8938255edacd16c17fb0622593baa76c8ca8 new file mode 100644 index 0000000..5690ec0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/45ad8938255edacd16c17fb0622593baa76c8ca8 differ diff --git a/fuzz/corpus/alloc_ops/45bf9af07560bb3ff1f4f611214452bca820e813 b/fuzz/corpus/alloc_ops/45bf9af07560bb3ff1f4f611214452bca820e813 new file mode 100644 index 0000000..c91f4ac Binary files /dev/null and b/fuzz/corpus/alloc_ops/45bf9af07560bb3ff1f4f611214452bca820e813 differ diff --git a/fuzz/corpus/alloc_ops/45d19f11128b5ae37f2dba29d4447cc9ce668b26 b/fuzz/corpus/alloc_ops/45d19f11128b5ae37f2dba29d4447cc9ce668b26 new file mode 100644 index 0000000..c0f5f07 Binary files /dev/null and b/fuzz/corpus/alloc_ops/45d19f11128b5ae37f2dba29d4447cc9ce668b26 differ diff --git a/fuzz/corpus/alloc_ops/45e90d1521d63777e71b6689c1e54f244d37e4e1 b/fuzz/corpus/alloc_ops/45e90d1521d63777e71b6689c1e54f244d37e4e1 new file mode 100644 index 0000000..77ca12d Binary files /dev/null and b/fuzz/corpus/alloc_ops/45e90d1521d63777e71b6689c1e54f244d37e4e1 differ diff --git a/fuzz/corpus/alloc_ops/4610cd64bd94fb6ed81926113b046168765a62e2 b/fuzz/corpus/alloc_ops/4610cd64bd94fb6ed81926113b046168765a62e2 new file mode 100644 index 0000000..6a82810 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4610cd64bd94fb6ed81926113b046168765a62e2 differ diff --git a/fuzz/corpus/alloc_ops/462eccaf9899ce844454a6d04929ba1e6d1b6032 b/fuzz/corpus/alloc_ops/462eccaf9899ce844454a6d04929ba1e6d1b6032 new file mode 100644 index 0000000..8a85671 Binary files /dev/null and b/fuzz/corpus/alloc_ops/462eccaf9899ce844454a6d04929ba1e6d1b6032 differ diff --git a/fuzz/corpus/alloc_ops/46380500b28196da28938947850e2e4fc7c06325 b/fuzz/corpus/alloc_ops/46380500b28196da28938947850e2e4fc7c06325 new file mode 100644 index 0000000..8f4f706 Binary files /dev/null and b/fuzz/corpus/alloc_ops/46380500b28196da28938947850e2e4fc7c06325 differ diff --git a/fuzz/corpus/alloc_ops/46839d96680f8c70573407c990931821bc126d91 b/fuzz/corpus/alloc_ops/46839d96680f8c70573407c990931821bc126d91 new file mode 100644 index 0000000..bfd00b7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/46839d96680f8c70573407c990931821bc126d91 differ diff --git a/fuzz/corpus/alloc_ops/4694d4701708751d6157d4d9b50c14ffe82f3d54 b/fuzz/corpus/alloc_ops/4694d4701708751d6157d4d9b50c14ffe82f3d54 new file mode 100644 index 0000000..a368c8b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4694d4701708751d6157d4d9b50c14ffe82f3d54 differ diff --git a/fuzz/corpus/alloc_ops/469ec4a1379334a4169f793a6073124dc0135714 b/fuzz/corpus/alloc_ops/469ec4a1379334a4169f793a6073124dc0135714 new file mode 100644 index 0000000..01170a4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/469ec4a1379334a4169f793a6073124dc0135714 differ diff --git a/fuzz/corpus/alloc_ops/46af598c80bde0c1ed3c5fb4aa8b820d3b3083b9 b/fuzz/corpus/alloc_ops/46af598c80bde0c1ed3c5fb4aa8b820d3b3083b9 new file mode 100644 index 0000000..d5c8c65 Binary files /dev/null and b/fuzz/corpus/alloc_ops/46af598c80bde0c1ed3c5fb4aa8b820d3b3083b9 differ diff --git a/fuzz/corpus/alloc_ops/474317bc4793e212349e859eae8cd2bf259f8e56 b/fuzz/corpus/alloc_ops/474317bc4793e212349e859eae8cd2bf259f8e56 new file mode 100644 index 0000000..1f016fc Binary files /dev/null and b/fuzz/corpus/alloc_ops/474317bc4793e212349e859eae8cd2bf259f8e56 differ diff --git a/fuzz/corpus/alloc_ops/474a557f11d35b09f4256d60ea44aa09044a74ad b/fuzz/corpus/alloc_ops/474a557f11d35b09f4256d60ea44aa09044a74ad new file mode 100644 index 0000000..8b5ec2c Binary files /dev/null and b/fuzz/corpus/alloc_ops/474a557f11d35b09f4256d60ea44aa09044a74ad differ diff --git a/fuzz/corpus/alloc_ops/4766a352b3dbc378fb89a4cd38bb470b22d86558 b/fuzz/corpus/alloc_ops/4766a352b3dbc378fb89a4cd38bb470b22d86558 new file mode 100644 index 0000000..577d3dd Binary files /dev/null and b/fuzz/corpus/alloc_ops/4766a352b3dbc378fb89a4cd38bb470b22d86558 differ diff --git a/fuzz/corpus/alloc_ops/476b3cb0d23c323fa1a2859025e5f6c207ce941a b/fuzz/corpus/alloc_ops/476b3cb0d23c323fa1a2859025e5f6c207ce941a new file mode 100644 index 0000000..d74b0da Binary files /dev/null and b/fuzz/corpus/alloc_ops/476b3cb0d23c323fa1a2859025e5f6c207ce941a differ diff --git a/fuzz/corpus/alloc_ops/47927d5764bc6f55f211b8d3b6e08d8908a8ccc7 b/fuzz/corpus/alloc_ops/47927d5764bc6f55f211b8d3b6e08d8908a8ccc7 new file mode 100644 index 0000000..eaac8be Binary files /dev/null and b/fuzz/corpus/alloc_ops/47927d5764bc6f55f211b8d3b6e08d8908a8ccc7 differ diff --git a/fuzz/corpus/alloc_ops/479431a96a7c41b5fe2e1e25eede42725eb675a7 b/fuzz/corpus/alloc_ops/479431a96a7c41b5fe2e1e25eede42725eb675a7 new file mode 100644 index 0000000..97c177f Binary files /dev/null and b/fuzz/corpus/alloc_ops/479431a96a7c41b5fe2e1e25eede42725eb675a7 differ diff --git a/fuzz/corpus/alloc_ops/47e0c0c2855ec08d0ef0015255b8ca569a4b29e3 b/fuzz/corpus/alloc_ops/47e0c0c2855ec08d0ef0015255b8ca569a4b29e3 new file mode 100644 index 0000000..1ba124c Binary files /dev/null and b/fuzz/corpus/alloc_ops/47e0c0c2855ec08d0ef0015255b8ca569a4b29e3 differ diff --git a/fuzz/corpus/alloc_ops/4807bf45429033e9a25ce7ec7ffe07c08629a78a b/fuzz/corpus/alloc_ops/4807bf45429033e9a25ce7ec7ffe07c08629a78a new file mode 100644 index 0000000..a6f9954 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4807bf45429033e9a25ce7ec7ffe07c08629a78a differ diff --git a/fuzz/corpus/alloc_ops/4815d29d9c6803fcb89090baccf97355992f302d b/fuzz/corpus/alloc_ops/4815d29d9c6803fcb89090baccf97355992f302d new file mode 100644 index 0000000..43528c2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4815d29d9c6803fcb89090baccf97355992f302d differ diff --git a/fuzz/corpus/alloc_ops/483be5bf00d0fe042cff65c49d5b72e4683ace9d b/fuzz/corpus/alloc_ops/483be5bf00d0fe042cff65c49d5b72e4683ace9d new file mode 100644 index 0000000..4e2b9ca Binary files /dev/null and b/fuzz/corpus/alloc_ops/483be5bf00d0fe042cff65c49d5b72e4683ace9d differ diff --git a/fuzz/corpus/alloc_ops/4866fbda2c56657142a8e0a52ec09c4e754a6fe7 b/fuzz/corpus/alloc_ops/4866fbda2c56657142a8e0a52ec09c4e754a6fe7 new file mode 100644 index 0000000..345a3b3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4866fbda2c56657142a8e0a52ec09c4e754a6fe7 differ diff --git a/fuzz/corpus/alloc_ops/48a34c4e143cac9db4963449c83a110e5a39f9b9 b/fuzz/corpus/alloc_ops/48a34c4e143cac9db4963449c83a110e5a39f9b9 new file mode 100644 index 0000000..ec62cc5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/48a34c4e143cac9db4963449c83a110e5a39f9b9 differ diff --git a/fuzz/corpus/alloc_ops/48b41b87d471772466cddcd90fe99229b1d2b611 b/fuzz/corpus/alloc_ops/48b41b87d471772466cddcd90fe99229b1d2b611 new file mode 100644 index 0000000..99c479e Binary files /dev/null and b/fuzz/corpus/alloc_ops/48b41b87d471772466cddcd90fe99229b1d2b611 differ diff --git a/fuzz/corpus/alloc_ops/48d790035c04e3e3b3c3ad31e843533fccd6c25a b/fuzz/corpus/alloc_ops/48d790035c04e3e3b3c3ad31e843533fccd6c25a new file mode 100644 index 0000000..3d1a368 Binary files /dev/null and b/fuzz/corpus/alloc_ops/48d790035c04e3e3b3c3ad31e843533fccd6c25a differ diff --git a/fuzz/corpus/alloc_ops/48f6af9d5aac9016c616ae2a94e285064fc30336 b/fuzz/corpus/alloc_ops/48f6af9d5aac9016c616ae2a94e285064fc30336 new file mode 100644 index 0000000..c3f77a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/48f6af9d5aac9016c616ae2a94e285064fc30336 differ diff --git a/fuzz/corpus/alloc_ops/497add25cdc1758c4fede4220ea60c84052afaa1 b/fuzz/corpus/alloc_ops/497add25cdc1758c4fede4220ea60c84052afaa1 new file mode 100644 index 0000000..3af51e5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/497add25cdc1758c4fede4220ea60c84052afaa1 differ diff --git a/fuzz/corpus/alloc_ops/499535fdd907b964e5b2517c6014ebcdb52bf7f4 b/fuzz/corpus/alloc_ops/499535fdd907b964e5b2517c6014ebcdb52bf7f4 new file mode 100644 index 0000000..d35759a Binary files /dev/null and b/fuzz/corpus/alloc_ops/499535fdd907b964e5b2517c6014ebcdb52bf7f4 differ diff --git a/fuzz/corpus/alloc_ops/49a3dc1b6a03604c4c5b370076998aa7cf1fa519 b/fuzz/corpus/alloc_ops/49a3dc1b6a03604c4c5b370076998aa7cf1fa519 new file mode 100644 index 0000000..9f60439 Binary files /dev/null and b/fuzz/corpus/alloc_ops/49a3dc1b6a03604c4c5b370076998aa7cf1fa519 differ diff --git a/fuzz/corpus/alloc_ops/49ceae6bb56ee3567588ce83f2a269a06285dbee b/fuzz/corpus/alloc_ops/49ceae6bb56ee3567588ce83f2a269a06285dbee new file mode 100644 index 0000000..ba800e6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/49ceae6bb56ee3567588ce83f2a269a06285dbee differ diff --git a/fuzz/corpus/alloc_ops/4a5aa5713bee218ab73aa7846853dd9611bf32ec b/fuzz/corpus/alloc_ops/4a5aa5713bee218ab73aa7846853dd9611bf32ec new file mode 100644 index 0000000..fa4ad16 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4a5aa5713bee218ab73aa7846853dd9611bf32ec differ diff --git a/fuzz/corpus/alloc_ops/4a90758801bf420dadc6f9acdd44399dbe87a23f b/fuzz/corpus/alloc_ops/4a90758801bf420dadc6f9acdd44399dbe87a23f new file mode 100644 index 0000000..91abcf5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4a90758801bf420dadc6f9acdd44399dbe87a23f differ diff --git a/fuzz/corpus/alloc_ops/4ac1f1edc74955d97fc39ce9b24f8cfef8645c17 b/fuzz/corpus/alloc_ops/4ac1f1edc74955d97fc39ce9b24f8cfef8645c17 new file mode 100644 index 0000000..5a456b6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ac1f1edc74955d97fc39ce9b24f8cfef8645c17 differ diff --git a/fuzz/corpus/alloc_ops/4ace01cd92b918b925c174010b5ae719124956e8 b/fuzz/corpus/alloc_ops/4ace01cd92b918b925c174010b5ae719124956e8 new file mode 100644 index 0000000..95160d3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ace01cd92b918b925c174010b5ae719124956e8 differ diff --git a/fuzz/corpus/alloc_ops/4ad392f74604cd67e8caad002d66f6db4d2b4a18 b/fuzz/corpus/alloc_ops/4ad392f74604cd67e8caad002d66f6db4d2b4a18 new file mode 100644 index 0000000..6af8d7f Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ad392f74604cd67e8caad002d66f6db4d2b4a18 differ diff --git a/fuzz/corpus/alloc_ops/4ad4b03702500a67e155a99b4599159946a67df2 b/fuzz/corpus/alloc_ops/4ad4b03702500a67e155a99b4599159946a67df2 new file mode 100644 index 0000000..01877f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ad4b03702500a67e155a99b4599159946a67df2 differ diff --git a/fuzz/corpus/alloc_ops/4afbd658814e6689850c031d2dd976b20cc15cef b/fuzz/corpus/alloc_ops/4afbd658814e6689850c031d2dd976b20cc15cef new file mode 100644 index 0000000..ae74e32 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4afbd658814e6689850c031d2dd976b20cc15cef differ diff --git a/fuzz/corpus/alloc_ops/4b2b2950623c39b44fcedb9703cc2775e17f19e5 b/fuzz/corpus/alloc_ops/4b2b2950623c39b44fcedb9703cc2775e17f19e5 new file mode 100644 index 0000000..e94676f Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b2b2950623c39b44fcedb9703cc2775e17f19e5 differ diff --git a/fuzz/corpus/alloc_ops/4b426ab1214393b8e1daac3454867b59af7c5ccd b/fuzz/corpus/alloc_ops/4b426ab1214393b8e1daac3454867b59af7c5ccd new file mode 100644 index 0000000..e68d0ef Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b426ab1214393b8e1daac3454867b59af7c5ccd differ diff --git a/fuzz/corpus/alloc_ops/4b5e7001ff9d9397a3bd9952c8f916deb1301633 b/fuzz/corpus/alloc_ops/4b5e7001ff9d9397a3bd9952c8f916deb1301633 new file mode 100644 index 0000000..0ffc24b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b5e7001ff9d9397a3bd9952c8f916deb1301633 differ diff --git a/fuzz/corpus/alloc_ops/4b7445687f05b8c3e6833903185c8cc7d3ced8d6 b/fuzz/corpus/alloc_ops/4b7445687f05b8c3e6833903185c8cc7d3ced8d6 new file mode 100644 index 0000000..a105c01 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b7445687f05b8c3e6833903185c8cc7d3ced8d6 differ diff --git a/fuzz/corpus/alloc_ops/4b79c4f9b9a0ca1e3681cd100ad2c4bad41b36b9 b/fuzz/corpus/alloc_ops/4b79c4f9b9a0ca1e3681cd100ad2c4bad41b36b9 new file mode 100644 index 0000000..43a0732 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b79c4f9b9a0ca1e3681cd100ad2c4bad41b36b9 differ diff --git a/fuzz/corpus/alloc_ops/4b97a9bb8fe0790379ddfbc847328af4a3ab090f b/fuzz/corpus/alloc_ops/4b97a9bb8fe0790379ddfbc847328af4a3ab090f new file mode 100644 index 0000000..21d5324 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4b97a9bb8fe0790379ddfbc847328af4a3ab090f differ diff --git a/fuzz/corpus/alloc_ops/4bbd50a5777ad9a8ccbcce0f810c1334ad076e42 b/fuzz/corpus/alloc_ops/4bbd50a5777ad9a8ccbcce0f810c1334ad076e42 new file mode 100644 index 0000000..cedcb96 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4bbd50a5777ad9a8ccbcce0f810c1334ad076e42 differ diff --git a/fuzz/corpus/alloc_ops/4c128bb7086a756b7d041e29c7f3a6226df2f62b b/fuzz/corpus/alloc_ops/4c128bb7086a756b7d041e29c7f3a6226df2f62b new file mode 100644 index 0000000..a16340d Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c128bb7086a756b7d041e29c7f3a6226df2f62b differ diff --git a/fuzz/corpus/alloc_ops/4c54763c210b7ddb201e252b75b7408d01902f84 b/fuzz/corpus/alloc_ops/4c54763c210b7ddb201e252b75b7408d01902f84 new file mode 100644 index 0000000..bcd882d Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c54763c210b7ddb201e252b75b7408d01902f84 differ diff --git a/fuzz/corpus/alloc_ops/4c5eee52715eed2f13f602095106d8c0ff273c4b b/fuzz/corpus/alloc_ops/4c5eee52715eed2f13f602095106d8c0ff273c4b new file mode 100644 index 0000000..955ca7c Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c5eee52715eed2f13f602095106d8c0ff273c4b differ diff --git a/fuzz/corpus/alloc_ops/4c67604734a0d5d79fd116e0b0c8d269c97f9f1d b/fuzz/corpus/alloc_ops/4c67604734a0d5d79fd116e0b0c8d269c97f9f1d new file mode 100644 index 0000000..aee8ef1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c67604734a0d5d79fd116e0b0c8d269c97f9f1d differ diff --git a/fuzz/corpus/alloc_ops/4c6d28fe15dfc5989e006496cf85da823c575049 b/fuzz/corpus/alloc_ops/4c6d28fe15dfc5989e006496cf85da823c575049 new file mode 100644 index 0000000..97b45a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c6d28fe15dfc5989e006496cf85da823c575049 differ diff --git a/fuzz/corpus/alloc_ops/4c8e78c671debfcacbe5c5dc3c6f9f6daf7fe326 b/fuzz/corpus/alloc_ops/4c8e78c671debfcacbe5c5dc3c6f9f6daf7fe326 new file mode 100644 index 0000000..06a432c Binary files /dev/null and b/fuzz/corpus/alloc_ops/4c8e78c671debfcacbe5c5dc3c6f9f6daf7fe326 differ diff --git a/fuzz/corpus/alloc_ops/4cb1053002a1b742af4a7524eac858ebfa9fc54f b/fuzz/corpus/alloc_ops/4cb1053002a1b742af4a7524eac858ebfa9fc54f new file mode 100644 index 0000000..d407dac Binary files /dev/null and b/fuzz/corpus/alloc_ops/4cb1053002a1b742af4a7524eac858ebfa9fc54f differ diff --git a/fuzz/corpus/alloc_ops/4cc5755445f5cd68fc92aaf0d2e9fa0a9af0ea49 b/fuzz/corpus/alloc_ops/4cc5755445f5cd68fc92aaf0d2e9fa0a9af0ea49 new file mode 100644 index 0000000..082bf7a Binary files /dev/null and b/fuzz/corpus/alloc_ops/4cc5755445f5cd68fc92aaf0d2e9fa0a9af0ea49 differ diff --git a/fuzz/corpus/alloc_ops/4cf55389e61bad631e37ae7269987fcd9008b74e b/fuzz/corpus/alloc_ops/4cf55389e61bad631e37ae7269987fcd9008b74e new file mode 100644 index 0000000..fc18de1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4cf55389e61bad631e37ae7269987fcd9008b74e differ diff --git a/fuzz/corpus/alloc_ops/4d09794dac44ed836acca76e457027ed3d311aa4 b/fuzz/corpus/alloc_ops/4d09794dac44ed836acca76e457027ed3d311aa4 new file mode 100644 index 0000000..caa141d Binary files /dev/null and b/fuzz/corpus/alloc_ops/4d09794dac44ed836acca76e457027ed3d311aa4 differ diff --git a/fuzz/corpus/alloc_ops/4d24c5ffcc3d3d4d14a5364a99f4f4c75dbd25e8 b/fuzz/corpus/alloc_ops/4d24c5ffcc3d3d4d14a5364a99f4f4c75dbd25e8 new file mode 100644 index 0000000..367df5b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4d24c5ffcc3d3d4d14a5364a99f4f4c75dbd25e8 differ diff --git a/fuzz/corpus/alloc_ops/4db2552e944b8a6f7bd0b5bfee1aa404615ebf12 b/fuzz/corpus/alloc_ops/4db2552e944b8a6f7bd0b5bfee1aa404615ebf12 new file mode 100644 index 0000000..ab9dba5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4db2552e944b8a6f7bd0b5bfee1aa404615ebf12 differ diff --git a/fuzz/corpus/alloc_ops/4dd6108b20538f9dec44ed1f4a24cb4193383805 b/fuzz/corpus/alloc_ops/4dd6108b20538f9dec44ed1f4a24cb4193383805 new file mode 100644 index 0000000..02dba7f Binary files /dev/null and b/fuzz/corpus/alloc_ops/4dd6108b20538f9dec44ed1f4a24cb4193383805 differ diff --git a/fuzz/corpus/alloc_ops/4ddf72003f50cab138a176182c378d1f56c6d59d b/fuzz/corpus/alloc_ops/4ddf72003f50cab138a176182c378d1f56c6d59d new file mode 100644 index 0000000..ecd7ba4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ddf72003f50cab138a176182c378d1f56c6d59d differ diff --git a/fuzz/corpus/alloc_ops/4df0d2cf8115f24252c0cfe2e4799a52279d17c0 b/fuzz/corpus/alloc_ops/4df0d2cf8115f24252c0cfe2e4799a52279d17c0 new file mode 100644 index 0000000..89ed3fa Binary files /dev/null and b/fuzz/corpus/alloc_ops/4df0d2cf8115f24252c0cfe2e4799a52279d17c0 differ diff --git a/fuzz/corpus/alloc_ops/4e0439b3f3b4e1faacb1b6ba9fe1e939f61da222 b/fuzz/corpus/alloc_ops/4e0439b3f3b4e1faacb1b6ba9fe1e939f61da222 new file mode 100644 index 0000000..c232799 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4e0439b3f3b4e1faacb1b6ba9fe1e939f61da222 differ diff --git a/fuzz/corpus/alloc_ops/4e46f39f762fddb5aaaa664047f58453c5e86983 b/fuzz/corpus/alloc_ops/4e46f39f762fddb5aaaa664047f58453c5e86983 new file mode 100644 index 0000000..a789fd3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4e46f39f762fddb5aaaa664047f58453c5e86983 differ diff --git a/fuzz/corpus/alloc_ops/4e580a277bd2c450d2730fdda943b75181fd1b4f b/fuzz/corpus/alloc_ops/4e580a277bd2c450d2730fdda943b75181fd1b4f new file mode 100644 index 0000000..781f4c9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4e580a277bd2c450d2730fdda943b75181fd1b4f differ diff --git a/fuzz/corpus/alloc_ops/4e68e97bab77a9f6761adf9c3d350e117a5fb161 b/fuzz/corpus/alloc_ops/4e68e97bab77a9f6761adf9c3d350e117a5fb161 new file mode 100644 index 0000000..d0574bb Binary files /dev/null and b/fuzz/corpus/alloc_ops/4e68e97bab77a9f6761adf9c3d350e117a5fb161 differ diff --git a/fuzz/corpus/alloc_ops/4e6a74340c42a0d8a0dbb33f326f1e9b6a8e3a20 b/fuzz/corpus/alloc_ops/4e6a74340c42a0d8a0dbb33f326f1e9b6a8e3a20 new file mode 100644 index 0000000..f6cb539 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4e6a74340c42a0d8a0dbb33f326f1e9b6a8e3a20 differ diff --git a/fuzz/corpus/alloc_ops/4ea00d6d1fd23a2bfbfdee07a19436ec0ff4babd b/fuzz/corpus/alloc_ops/4ea00d6d1fd23a2bfbfdee07a19436ec0ff4babd new file mode 100644 index 0000000..9fe11d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ea00d6d1fd23a2bfbfdee07a19436ec0ff4babd differ diff --git a/fuzz/corpus/alloc_ops/4eb4dc543d86eb707c2720d0a873c2780434f860 b/fuzz/corpus/alloc_ops/4eb4dc543d86eb707c2720d0a873c2780434f860 new file mode 100644 index 0000000..412648a Binary files /dev/null and b/fuzz/corpus/alloc_ops/4eb4dc543d86eb707c2720d0a873c2780434f860 differ diff --git a/fuzz/corpus/alloc_ops/4efd048ecaabe144d31945da616f64c5b19ed9e3 b/fuzz/corpus/alloc_ops/4efd048ecaabe144d31945da616f64c5b19ed9e3 new file mode 100644 index 0000000..8cafb81 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4efd048ecaabe144d31945da616f64c5b19ed9e3 differ diff --git a/fuzz/corpus/alloc_ops/4f0455a3c6c697c047adb392ac8c9f51c073b209 b/fuzz/corpus/alloc_ops/4f0455a3c6c697c047adb392ac8c9f51c073b209 new file mode 100644 index 0000000..d741975 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4f0455a3c6c697c047adb392ac8c9f51c073b209 differ diff --git a/fuzz/corpus/alloc_ops/4f10c14844d696cb283aa5e8a3b7afb2c82597e5 b/fuzz/corpus/alloc_ops/4f10c14844d696cb283aa5e8a3b7afb2c82597e5 new file mode 100644 index 0000000..e91a316 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4f10c14844d696cb283aa5e8a3b7afb2c82597e5 differ diff --git a/fuzz/corpus/alloc_ops/4f4732288f042b3e71da360429f1f338c02d0ba9 b/fuzz/corpus/alloc_ops/4f4732288f042b3e71da360429f1f338c02d0ba9 new file mode 100644 index 0000000..671e1f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4f4732288f042b3e71da360429f1f338c02d0ba9 differ diff --git a/fuzz/corpus/alloc_ops/4fa22ac23e29f7b3fadab92904f1674313fb4565 b/fuzz/corpus/alloc_ops/4fa22ac23e29f7b3fadab92904f1674313fb4565 new file mode 100644 index 0000000..13e86ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/4fa22ac23e29f7b3fadab92904f1674313fb4565 differ diff --git a/fuzz/corpus/alloc_ops/4fa478941294f67be07b20b7f15c6948f045d8ca b/fuzz/corpus/alloc_ops/4fa478941294f67be07b20b7f15c6948f045d8ca new file mode 100644 index 0000000..803dd0b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4fa478941294f67be07b20b7f15c6948f045d8ca differ diff --git a/fuzz/corpus/alloc_ops/4fea275ed6ce4268bfb9af5f47a6fea816b4d2e6 b/fuzz/corpus/alloc_ops/4fea275ed6ce4268bfb9af5f47a6fea816b4d2e6 new file mode 100644 index 0000000..a9f015f Binary files /dev/null and b/fuzz/corpus/alloc_ops/4fea275ed6ce4268bfb9af5f47a6fea816b4d2e6 differ diff --git a/fuzz/corpus/alloc_ops/4ff8641fc1aa9081868a54e554122d87122c35c0 b/fuzz/corpus/alloc_ops/4ff8641fc1aa9081868a54e554122d87122c35c0 new file mode 100644 index 0000000..d4b2e7b Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ff8641fc1aa9081868a54e554122d87122c35c0 differ diff --git a/fuzz/corpus/alloc_ops/4ffabb3e8bbc770ad56e327f00e4d36a55cebee6 b/fuzz/corpus/alloc_ops/4ffabb3e8bbc770ad56e327f00e4d36a55cebee6 new file mode 100644 index 0000000..e6d3b50 Binary files /dev/null and b/fuzz/corpus/alloc_ops/4ffabb3e8bbc770ad56e327f00e4d36a55cebee6 differ diff --git a/fuzz/corpus/alloc_ops/4ffd1f08d0db0ccc7bc2481756b10746a3c132a2 b/fuzz/corpus/alloc_ops/4ffd1f08d0db0ccc7bc2481756b10746a3c132a2 new file mode 100644 index 0000000..3a250cd --- /dev/null +++ b/fuzz/corpus/alloc_ops/4ffd1f08d0db0ccc7bc2481756b10746a3c132a2 @@ -0,0 +1 @@ +öööööööööööööööööööööööööwöö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/507f0001e2df8276c4d0930e24f8e6023b39e01f b/fuzz/corpus/alloc_ops/507f0001e2df8276c4d0930e24f8e6023b39e01f new file mode 100644 index 0000000..c68dbe5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/507f0001e2df8276c4d0930e24f8e6023b39e01f differ diff --git a/fuzz/corpus/alloc_ops/507f15e717b3fddf817e32869465d65c6da12320 b/fuzz/corpus/alloc_ops/507f15e717b3fddf817e32869465d65c6da12320 new file mode 100644 index 0000000..d2cb76d Binary files /dev/null and b/fuzz/corpus/alloc_ops/507f15e717b3fddf817e32869465d65c6da12320 differ diff --git a/fuzz/corpus/alloc_ops/5113f4ae2472e0820050984f65dc192fd75bd266 b/fuzz/corpus/alloc_ops/5113f4ae2472e0820050984f65dc192fd75bd266 new file mode 100644 index 0000000..c7b8006 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5113f4ae2472e0820050984f65dc192fd75bd266 differ diff --git a/fuzz/corpus/alloc_ops/517eaa74cc61a71f2a7e1d6476e78189a28dd321 b/fuzz/corpus/alloc_ops/517eaa74cc61a71f2a7e1d6476e78189a28dd321 new file mode 100644 index 0000000..2e88560 Binary files /dev/null and b/fuzz/corpus/alloc_ops/517eaa74cc61a71f2a7e1d6476e78189a28dd321 differ diff --git a/fuzz/corpus/alloc_ops/51b098a1dd6b5b3a3f56ee1a8bc7895ab0962ffa b/fuzz/corpus/alloc_ops/51b098a1dd6b5b3a3f56ee1a8bc7895ab0962ffa new file mode 100644 index 0000000..e8371d0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/51b098a1dd6b5b3a3f56ee1a8bc7895ab0962ffa differ diff --git a/fuzz/corpus/alloc_ops/51c60edad9ef4866db0f0ce1fe954b6e2f286ef2 b/fuzz/corpus/alloc_ops/51c60edad9ef4866db0f0ce1fe954b6e2f286ef2 new file mode 100644 index 0000000..e5ee8f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/51c60edad9ef4866db0f0ce1fe954b6e2f286ef2 differ diff --git a/fuzz/corpus/alloc_ops/51d8e25a775ce6f988144f1b88f045b9fbe17c7e b/fuzz/corpus/alloc_ops/51d8e25a775ce6f988144f1b88f045b9fbe17c7e new file mode 100644 index 0000000..d2a57d8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/51d8e25a775ce6f988144f1b88f045b9fbe17c7e differ diff --git a/fuzz/corpus/alloc_ops/51ec41a6b947b8316372b2fcab0b77ba78a5a13c b/fuzz/corpus/alloc_ops/51ec41a6b947b8316372b2fcab0b77ba78a5a13c new file mode 100644 index 0000000..3526d63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/51ec41a6b947b8316372b2fcab0b77ba78a5a13c differ diff --git a/fuzz/corpus/alloc_ops/521ab76ba5145d335e4e66ae239bf28ddba08832 b/fuzz/corpus/alloc_ops/521ab76ba5145d335e4e66ae239bf28ddba08832 new file mode 100644 index 0000000..ab23192 Binary files /dev/null and b/fuzz/corpus/alloc_ops/521ab76ba5145d335e4e66ae239bf28ddba08832 differ diff --git a/fuzz/corpus/alloc_ops/525d80cecfef9126554554b5791d8fa8529d91bb b/fuzz/corpus/alloc_ops/525d80cecfef9126554554b5791d8fa8529d91bb new file mode 100644 index 0000000..e13fba9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/525d80cecfef9126554554b5791d8fa8529d91bb differ diff --git a/fuzz/corpus/alloc_ops/5270770f6d85d567f9fb75348f57976452ff42e5 b/fuzz/corpus/alloc_ops/5270770f6d85d567f9fb75348f57976452ff42e5 new file mode 100644 index 0000000..0cbea38 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5270770f6d85d567f9fb75348f57976452ff42e5 differ diff --git a/fuzz/corpus/alloc_ops/52810f179b4fd514584fe1adffad20f6bc92e5a9 b/fuzz/corpus/alloc_ops/52810f179b4fd514584fe1adffad20f6bc92e5a9 new file mode 100644 index 0000000..de08bb5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/52810f179b4fd514584fe1adffad20f6bc92e5a9 differ diff --git a/fuzz/corpus/alloc_ops/529e56ce2c17149fc9217f9001e3da0755507834 b/fuzz/corpus/alloc_ops/529e56ce2c17149fc9217f9001e3da0755507834 new file mode 100644 index 0000000..b80ee14 Binary files /dev/null and b/fuzz/corpus/alloc_ops/529e56ce2c17149fc9217f9001e3da0755507834 differ diff --git a/fuzz/corpus/alloc_ops/52b99ff4c05baab6953f7c5dcdf5983f863e109c b/fuzz/corpus/alloc_ops/52b99ff4c05baab6953f7c5dcdf5983f863e109c new file mode 100644 index 0000000..ff0d2bc Binary files /dev/null and b/fuzz/corpus/alloc_ops/52b99ff4c05baab6953f7c5dcdf5983f863e109c differ diff --git a/fuzz/corpus/alloc_ops/537986f8a9a935bca4c287decd17d37dc2b2288f b/fuzz/corpus/alloc_ops/537986f8a9a935bca4c287decd17d37dc2b2288f new file mode 100644 index 0000000..ab6f1a5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/537986f8a9a935bca4c287decd17d37dc2b2288f differ diff --git a/fuzz/corpus/alloc_ops/5412679267efab91c35d44af14f312c8cb6029bb b/fuzz/corpus/alloc_ops/5412679267efab91c35d44af14f312c8cb6029bb new file mode 100644 index 0000000..20d73f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5412679267efab91c35d44af14f312c8cb6029bb differ diff --git a/fuzz/corpus/alloc_ops/544c6a6bbac34d4f629c305366040a70efb5f3df b/fuzz/corpus/alloc_ops/544c6a6bbac34d4f629c305366040a70efb5f3df new file mode 100644 index 0000000..6736174 Binary files /dev/null and b/fuzz/corpus/alloc_ops/544c6a6bbac34d4f629c305366040a70efb5f3df differ diff --git a/fuzz/corpus/alloc_ops/54666aeadbac83c1b2fcbc8a3c4a05ddb90d3f51 b/fuzz/corpus/alloc_ops/54666aeadbac83c1b2fcbc8a3c4a05ddb90d3f51 new file mode 100644 index 0000000..f827e8a Binary files /dev/null and b/fuzz/corpus/alloc_ops/54666aeadbac83c1b2fcbc8a3c4a05ddb90d3f51 differ diff --git a/fuzz/corpus/alloc_ops/54822a93f2c8e1984b9e43cc8931d8a3146d05ae b/fuzz/corpus/alloc_ops/54822a93f2c8e1984b9e43cc8931d8a3146d05ae new file mode 100644 index 0000000..7cb6c02 Binary files /dev/null and b/fuzz/corpus/alloc_ops/54822a93f2c8e1984b9e43cc8931d8a3146d05ae differ diff --git a/fuzz/corpus/alloc_ops/548ab4543fd1a60d2842dafd6dc384b709e8d2f1 b/fuzz/corpus/alloc_ops/548ab4543fd1a60d2842dafd6dc384b709e8d2f1 new file mode 100644 index 0000000..a345cf3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/548ab4543fd1a60d2842dafd6dc384b709e8d2f1 differ diff --git a/fuzz/corpus/alloc_ops/54b399e564c3bf1cefdd399cd04bc4bce662e173 b/fuzz/corpus/alloc_ops/54b399e564c3bf1cefdd399cd04bc4bce662e173 new file mode 100644 index 0000000..29e7c4c Binary files /dev/null and b/fuzz/corpus/alloc_ops/54b399e564c3bf1cefdd399cd04bc4bce662e173 differ diff --git a/fuzz/corpus/alloc_ops/54dc2d06468e2457f9a1428998e68574459773ba b/fuzz/corpus/alloc_ops/54dc2d06468e2457f9a1428998e68574459773ba new file mode 100644 index 0000000..8ac776d Binary files /dev/null and b/fuzz/corpus/alloc_ops/54dc2d06468e2457f9a1428998e68574459773ba differ diff --git a/fuzz/corpus/alloc_ops/54f63b9e40fb72bb8d3fc69c9d79d5ec604b90bb b/fuzz/corpus/alloc_ops/54f63b9e40fb72bb8d3fc69c9d79d5ec604b90bb new file mode 100644 index 0000000..b7ba440 Binary files /dev/null and b/fuzz/corpus/alloc_ops/54f63b9e40fb72bb8d3fc69c9d79d5ec604b90bb differ diff --git a/fuzz/corpus/alloc_ops/5517cba6f21176ca41365f17ceeaf83959e83152 b/fuzz/corpus/alloc_ops/5517cba6f21176ca41365f17ceeaf83959e83152 new file mode 100644 index 0000000..465f8cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/5517cba6f21176ca41365f17ceeaf83959e83152 differ diff --git a/fuzz/corpus/alloc_ops/556afda281ea79db1a95abc57c5a96c06ae8cff2 b/fuzz/corpus/alloc_ops/556afda281ea79db1a95abc57c5a96c06ae8cff2 new file mode 100644 index 0000000..3d783e8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/556afda281ea79db1a95abc57c5a96c06ae8cff2 differ diff --git a/fuzz/corpus/alloc_ops/559e60dd025b307eb8bec499eda1b45cc72cc6a2 b/fuzz/corpus/alloc_ops/559e60dd025b307eb8bec499eda1b45cc72cc6a2 new file mode 100644 index 0000000..9471bc2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/559e60dd025b307eb8bec499eda1b45cc72cc6a2 differ diff --git a/fuzz/corpus/alloc_ops/55fe5d935295400cc4c088a947ba133dca77738b b/fuzz/corpus/alloc_ops/55fe5d935295400cc4c088a947ba133dca77738b new file mode 100644 index 0000000..ea67ffa Binary files /dev/null and b/fuzz/corpus/alloc_ops/55fe5d935295400cc4c088a947ba133dca77738b differ diff --git a/fuzz/corpus/alloc_ops/560e1c667b354c3a8380fa98896d707ce4ce3c1d b/fuzz/corpus/alloc_ops/560e1c667b354c3a8380fa98896d707ce4ce3c1d new file mode 100644 index 0000000..df05c2a Binary files /dev/null and b/fuzz/corpus/alloc_ops/560e1c667b354c3a8380fa98896d707ce4ce3c1d differ diff --git a/fuzz/corpus/alloc_ops/561f9f1e906082493bba7be9d95c224f0dfa7ae7 b/fuzz/corpus/alloc_ops/561f9f1e906082493bba7be9d95c224f0dfa7ae7 new file mode 100644 index 0000000..95894a0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/561f9f1e906082493bba7be9d95c224f0dfa7ae7 differ diff --git a/fuzz/corpus/alloc_ops/56914f46c2bd0d5912ac7ef1ca3541e054818b02 b/fuzz/corpus/alloc_ops/56914f46c2bd0d5912ac7ef1ca3541e054818b02 new file mode 100644 index 0000000..4da7e17 Binary files /dev/null and b/fuzz/corpus/alloc_ops/56914f46c2bd0d5912ac7ef1ca3541e054818b02 differ diff --git a/fuzz/corpus/alloc_ops/5691c99e0ea31bac969506d57f99572262afb0f8 b/fuzz/corpus/alloc_ops/5691c99e0ea31bac969506d57f99572262afb0f8 new file mode 100644 index 0000000..cf3ca22 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5691c99e0ea31bac969506d57f99572262afb0f8 differ diff --git a/fuzz/corpus/alloc_ops/56cb4adf0c00e8c21e3ccf890e7bb82eda9fb25e b/fuzz/corpus/alloc_ops/56cb4adf0c00e8c21e3ccf890e7bb82eda9fb25e new file mode 100644 index 0000000..925b6f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/56cb4adf0c00e8c21e3ccf890e7bb82eda9fb25e differ diff --git a/fuzz/corpus/alloc_ops/56eacb7303b44ec40345f01e8246d26b6a9c2d17 b/fuzz/corpus/alloc_ops/56eacb7303b44ec40345f01e8246d26b6a9c2d17 new file mode 100644 index 0000000..b009421 Binary files /dev/null and b/fuzz/corpus/alloc_ops/56eacb7303b44ec40345f01e8246d26b6a9c2d17 differ diff --git a/fuzz/corpus/alloc_ops/578c32116c31afb25a42c9ab28b4a4865afc75d6 b/fuzz/corpus/alloc_ops/578c32116c31afb25a42c9ab28b4a4865afc75d6 new file mode 100644 index 0000000..3baa26e Binary files /dev/null and b/fuzz/corpus/alloc_ops/578c32116c31afb25a42c9ab28b4a4865afc75d6 differ diff --git a/fuzz/corpus/alloc_ops/57a09217057a9df1e0b55f9db19e570cf80e23ff b/fuzz/corpus/alloc_ops/57a09217057a9df1e0b55f9db19e570cf80e23ff new file mode 100644 index 0000000..d524977 Binary files /dev/null and b/fuzz/corpus/alloc_ops/57a09217057a9df1e0b55f9db19e570cf80e23ff differ diff --git a/fuzz/corpus/alloc_ops/57c14691fbadeec6a489fb9cf415e97a537d13de b/fuzz/corpus/alloc_ops/57c14691fbadeec6a489fb9cf415e97a537d13de new file mode 100644 index 0000000..cee1d2f Binary files /dev/null and b/fuzz/corpus/alloc_ops/57c14691fbadeec6a489fb9cf415e97a537d13de differ diff --git a/fuzz/corpus/alloc_ops/57e0388bd7b58378b6547095c5c9c747f17901ce b/fuzz/corpus/alloc_ops/57e0388bd7b58378b6547095c5c9c747f17901ce new file mode 100644 index 0000000..c7d2f0c Binary files /dev/null and b/fuzz/corpus/alloc_ops/57e0388bd7b58378b6547095c5c9c747f17901ce differ diff --git a/fuzz/corpus/alloc_ops/57f533fec18b131843a85991d74c33d9cdc83f9a b/fuzz/corpus/alloc_ops/57f533fec18b131843a85991d74c33d9cdc83f9a new file mode 100644 index 0000000..4cb5dfb Binary files /dev/null and b/fuzz/corpus/alloc_ops/57f533fec18b131843a85991d74c33d9cdc83f9a differ diff --git a/fuzz/corpus/alloc_ops/5822f2b0fe38841e74ef17c18c2ac2378c52fc2a b/fuzz/corpus/alloc_ops/5822f2b0fe38841e74ef17c18c2ac2378c52fc2a new file mode 100644 index 0000000..a2d4137 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5822f2b0fe38841e74ef17c18c2ac2378c52fc2a differ diff --git a/fuzz/corpus/alloc_ops/58246b9eb23b91c81e65c32dbce53572f4e94e77 b/fuzz/corpus/alloc_ops/58246b9eb23b91c81e65c32dbce53572f4e94e77 new file mode 100644 index 0000000..3b32da7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/58246b9eb23b91c81e65c32dbce53572f4e94e77 differ diff --git a/fuzz/corpus/alloc_ops/5851c0a25728b9dc2609c3e8b446cff7a75af52b b/fuzz/corpus/alloc_ops/5851c0a25728b9dc2609c3e8b446cff7a75af52b new file mode 100644 index 0000000..69e1b20 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5851c0a25728b9dc2609c3e8b446cff7a75af52b differ diff --git a/fuzz/corpus/alloc_ops/5859d71bf3e39721ea70be0cded03617636c261d b/fuzz/corpus/alloc_ops/5859d71bf3e39721ea70be0cded03617636c261d new file mode 100644 index 0000000..523756f Binary files /dev/null and b/fuzz/corpus/alloc_ops/5859d71bf3e39721ea70be0cded03617636c261d differ diff --git a/fuzz/corpus/alloc_ops/58a26c5224fd8f51fa882edabb8c02a2b187b542 b/fuzz/corpus/alloc_ops/58a26c5224fd8f51fa882edabb8c02a2b187b542 new file mode 100644 index 0000000..7626eaf Binary files /dev/null and b/fuzz/corpus/alloc_ops/58a26c5224fd8f51fa882edabb8c02a2b187b542 differ diff --git a/fuzz/corpus/alloc_ops/58d70ef543ae966d254ccd7189ee31f1d95c1c0f b/fuzz/corpus/alloc_ops/58d70ef543ae966d254ccd7189ee31f1d95c1c0f new file mode 100644 index 0000000..badf782 Binary files /dev/null and b/fuzz/corpus/alloc_ops/58d70ef543ae966d254ccd7189ee31f1d95c1c0f differ diff --git a/fuzz/corpus/alloc_ops/590fb3e261ae5d14f99af897637d8ce0f7a5e66c b/fuzz/corpus/alloc_ops/590fb3e261ae5d14f99af897637d8ce0f7a5e66c new file mode 100644 index 0000000..1287799 Binary files /dev/null and b/fuzz/corpus/alloc_ops/590fb3e261ae5d14f99af897637d8ce0f7a5e66c differ diff --git a/fuzz/corpus/alloc_ops/5950a2a472ee3d92393a8ef4acdfb9e17c074428 b/fuzz/corpus/alloc_ops/5950a2a472ee3d92393a8ef4acdfb9e17c074428 new file mode 100644 index 0000000..ff6dbed Binary files /dev/null and b/fuzz/corpus/alloc_ops/5950a2a472ee3d92393a8ef4acdfb9e17c074428 differ diff --git a/fuzz/corpus/alloc_ops/595bf3d6a783f5bff05da2ca9b330a907879e490 b/fuzz/corpus/alloc_ops/595bf3d6a783f5bff05da2ca9b330a907879e490 new file mode 100644 index 0000000..1800f17 Binary files /dev/null and b/fuzz/corpus/alloc_ops/595bf3d6a783f5bff05da2ca9b330a907879e490 differ diff --git a/fuzz/corpus/alloc_ops/596708614941d062282dc57acd276df1fdf45279 b/fuzz/corpus/alloc_ops/596708614941d062282dc57acd276df1fdf45279 new file mode 100644 index 0000000..743036b Binary files /dev/null and b/fuzz/corpus/alloc_ops/596708614941d062282dc57acd276df1fdf45279 differ diff --git a/fuzz/corpus/alloc_ops/59972f5ffc25736d3948ac3a1b787c656ba7603b b/fuzz/corpus/alloc_ops/59972f5ffc25736d3948ac3a1b787c656ba7603b new file mode 100644 index 0000000..3f3ce5e Binary files /dev/null and b/fuzz/corpus/alloc_ops/59972f5ffc25736d3948ac3a1b787c656ba7603b differ diff --git a/fuzz/corpus/alloc_ops/59a5f92dda75c7fbd9dbb92de24f1b298f6488d6 b/fuzz/corpus/alloc_ops/59a5f92dda75c7fbd9dbb92de24f1b298f6488d6 new file mode 100644 index 0000000..2c37ca4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/59a5f92dda75c7fbd9dbb92de24f1b298f6488d6 differ diff --git a/fuzz/corpus/alloc_ops/59b89384d79818a408d0dd6079ce9e8e2b84de35 b/fuzz/corpus/alloc_ops/59b89384d79818a408d0dd6079ce9e8e2b84de35 new file mode 100644 index 0000000..bd3586a Binary files /dev/null and b/fuzz/corpus/alloc_ops/59b89384d79818a408d0dd6079ce9e8e2b84de35 differ diff --git a/fuzz/corpus/alloc_ops/59dd7fc0244a7386491a47bdc9418456439b0e59 b/fuzz/corpus/alloc_ops/59dd7fc0244a7386491a47bdc9418456439b0e59 new file mode 100644 index 0000000..ad4206e --- /dev/null +++ b/fuzz/corpus/alloc_ops/59dd7fc0244a7386491a47bdc9418456439b0e59 @@ -0,0 +1 @@ +þµþþþþþþþþþþþ#2þþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/5a14448d706b71d882401b7b49e34900985bfa66 b/fuzz/corpus/alloc_ops/5a14448d706b71d882401b7b49e34900985bfa66 new file mode 100644 index 0000000..ee51da2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5a14448d706b71d882401b7b49e34900985bfa66 differ diff --git a/fuzz/corpus/alloc_ops/5a26025ceade5d96a6f106bb84be1679781e3bf0 b/fuzz/corpus/alloc_ops/5a26025ceade5d96a6f106bb84be1679781e3bf0 new file mode 100644 index 0000000..bcac69a Binary files /dev/null and b/fuzz/corpus/alloc_ops/5a26025ceade5d96a6f106bb84be1679781e3bf0 differ diff --git a/fuzz/corpus/alloc_ops/5a8ef4f64857fc03a63a7a43fb003596fdc9f41a b/fuzz/corpus/alloc_ops/5a8ef4f64857fc03a63a7a43fb003596fdc9f41a new file mode 100644 index 0000000..4c223b1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5a8ef4f64857fc03a63a7a43fb003596fdc9f41a differ diff --git a/fuzz/corpus/alloc_ops/5ab8d475cb268c6cb1b2b6c1fe7e9f7fcaa074a0 b/fuzz/corpus/alloc_ops/5ab8d475cb268c6cb1b2b6c1fe7e9f7fcaa074a0 new file mode 100644 index 0000000..a61e464 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5ab8d475cb268c6cb1b2b6c1fe7e9f7fcaa074a0 differ diff --git a/fuzz/corpus/alloc_ops/5ac1089b67e856c3e7184b44fe02d6bb1500f71b b/fuzz/corpus/alloc_ops/5ac1089b67e856c3e7184b44fe02d6bb1500f71b new file mode 100644 index 0000000..a18cdd6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5ac1089b67e856c3e7184b44fe02d6bb1500f71b differ diff --git a/fuzz/corpus/alloc_ops/5ac644a4f01494435880ca56874703db127eb098 b/fuzz/corpus/alloc_ops/5ac644a4f01494435880ca56874703db127eb098 new file mode 100644 index 0000000..789e302 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5ac644a4f01494435880ca56874703db127eb098 differ diff --git a/fuzz/corpus/alloc_ops/5af7a24244aa5ec1d687cd2ecc661e7bbc2ce086 b/fuzz/corpus/alloc_ops/5af7a24244aa5ec1d687cd2ecc661e7bbc2ce086 new file mode 100644 index 0000000..5d3924b Binary files /dev/null and b/fuzz/corpus/alloc_ops/5af7a24244aa5ec1d687cd2ecc661e7bbc2ce086 differ diff --git a/fuzz/corpus/alloc_ops/5b5dc40cb62499d27b5a4fca927df8ef119c8503 b/fuzz/corpus/alloc_ops/5b5dc40cb62499d27b5a4fca927df8ef119c8503 new file mode 100644 index 0000000..937cfcd Binary files /dev/null and b/fuzz/corpus/alloc_ops/5b5dc40cb62499d27b5a4fca927df8ef119c8503 differ diff --git a/fuzz/corpus/alloc_ops/5b6650811719216d4e23a4a4318813c0979f443a b/fuzz/corpus/alloc_ops/5b6650811719216d4e23a4a4318813c0979f443a new file mode 100644 index 0000000..4007ef8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5b6650811719216d4e23a4a4318813c0979f443a differ diff --git a/fuzz/corpus/alloc_ops/5b8c5c70be177f6339cd53af98e4c217b9efe394 b/fuzz/corpus/alloc_ops/5b8c5c70be177f6339cd53af98e4c217b9efe394 new file mode 100644 index 0000000..28d8681 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5b8c5c70be177f6339cd53af98e4c217b9efe394 differ diff --git a/fuzz/corpus/alloc_ops/5c0aa41ccf595f9e391b92fae9f5ac62cb408e03 b/fuzz/corpus/alloc_ops/5c0aa41ccf595f9e391b92fae9f5ac62cb408e03 new file mode 100644 index 0000000..0900219 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c0aa41ccf595f9e391b92fae9f5ac62cb408e03 differ diff --git a/fuzz/corpus/alloc_ops/5c32390c1fca7659fb61f74a404e303f151a53d7 b/fuzz/corpus/alloc_ops/5c32390c1fca7659fb61f74a404e303f151a53d7 new file mode 100644 index 0000000..4da491d Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c32390c1fca7659fb61f74a404e303f151a53d7 differ diff --git a/fuzz/corpus/alloc_ops/5c3b7a462dbf9d13784d922dd93811c32ab504c7 b/fuzz/corpus/alloc_ops/5c3b7a462dbf9d13784d922dd93811c32ab504c7 new file mode 100644 index 0000000..b29b82a Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c3b7a462dbf9d13784d922dd93811c32ab504c7 differ diff --git a/fuzz/corpus/alloc_ops/5c56ab449bcdb15225c514de1e62553855c013d6 b/fuzz/corpus/alloc_ops/5c56ab449bcdb15225c514de1e62553855c013d6 new file mode 100644 index 0000000..a6a0f34 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c56ab449bcdb15225c514de1e62553855c013d6 differ diff --git a/fuzz/corpus/alloc_ops/5c5f6c465aedc0312dc5554a0435f2d8afd70eac b/fuzz/corpus/alloc_ops/5c5f6c465aedc0312dc5554a0435f2d8afd70eac new file mode 100644 index 0000000..0e9b631 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c5f6c465aedc0312dc5554a0435f2d8afd70eac differ diff --git a/fuzz/corpus/alloc_ops/5c6f6fd4e31feb0c023a63a7b3b7fb61fdee8c78 b/fuzz/corpus/alloc_ops/5c6f6fd4e31feb0c023a63a7b3b7fb61fdee8c78 new file mode 100644 index 0000000..5b757e1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c6f6fd4e31feb0c023a63a7b3b7fb61fdee8c78 differ diff --git a/fuzz/corpus/alloc_ops/5c88b0b553cbdbe44f03dd30c4bd6badddd5a3bb b/fuzz/corpus/alloc_ops/5c88b0b553cbdbe44f03dd30c4bd6badddd5a3bb new file mode 100644 index 0000000..20808ca Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c88b0b553cbdbe44f03dd30c4bd6badddd5a3bb differ diff --git a/fuzz/corpus/alloc_ops/5c98b74fd777ab877ea22aa8b2afcda42a06a771 b/fuzz/corpus/alloc_ops/5c98b74fd777ab877ea22aa8b2afcda42a06a771 new file mode 100644 index 0000000..f06b5fa Binary files /dev/null and b/fuzz/corpus/alloc_ops/5c98b74fd777ab877ea22aa8b2afcda42a06a771 differ diff --git a/fuzz/corpus/alloc_ops/5cc29b705b7d4f8e9a7a4630fcf5e8b5d26918e2 b/fuzz/corpus/alloc_ops/5cc29b705b7d4f8e9a7a4630fcf5e8b5d26918e2 new file mode 100644 index 0000000..596348b Binary files /dev/null and b/fuzz/corpus/alloc_ops/5cc29b705b7d4f8e9a7a4630fcf5e8b5d26918e2 differ diff --git a/fuzz/corpus/alloc_ops/5d21672a165e6f12394cfb157280e90369a5b55f b/fuzz/corpus/alloc_ops/5d21672a165e6f12394cfb157280e90369a5b55f new file mode 100644 index 0000000..1ea7352 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5d21672a165e6f12394cfb157280e90369a5b55f differ diff --git a/fuzz/corpus/alloc_ops/5d3a0576ef4bf1231f805da68f6461eacc6a5176 b/fuzz/corpus/alloc_ops/5d3a0576ef4bf1231f805da68f6461eacc6a5176 new file mode 100644 index 0000000..2f749b3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5d3a0576ef4bf1231f805da68f6461eacc6a5176 differ diff --git a/fuzz/corpus/alloc_ops/5d59503cb97ceaeda381c81c1d6d4774d028628a b/fuzz/corpus/alloc_ops/5d59503cb97ceaeda381c81c1d6d4774d028628a new file mode 100644 index 0000000..abb7517 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5d59503cb97ceaeda381c81c1d6d4774d028628a differ diff --git a/fuzz/corpus/alloc_ops/5d73cf89a16d65cc1401680eb5026a2f8ab7312f b/fuzz/corpus/alloc_ops/5d73cf89a16d65cc1401680eb5026a2f8ab7312f new file mode 100644 index 0000000..75e6f2e Binary files /dev/null and b/fuzz/corpus/alloc_ops/5d73cf89a16d65cc1401680eb5026a2f8ab7312f differ diff --git a/fuzz/corpus/alloc_ops/5d8c22227d5945a59e9e87db2f0dd0b4ea18368f b/fuzz/corpus/alloc_ops/5d8c22227d5945a59e9e87db2f0dd0b4ea18368f new file mode 100644 index 0000000..4482788 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5d8c22227d5945a59e9e87db2f0dd0b4ea18368f differ diff --git a/fuzz/corpus/alloc_ops/5e04fe3e62be288058b9f5adfa8ef8bf15f1143e b/fuzz/corpus/alloc_ops/5e04fe3e62be288058b9f5adfa8ef8bf15f1143e new file mode 100644 index 0000000..9dadc54 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5e04fe3e62be288058b9f5adfa8ef8bf15f1143e differ diff --git a/fuzz/corpus/alloc_ops/5e0f0426429af99ad8a2d4d63fe5e8423b33d604 b/fuzz/corpus/alloc_ops/5e0f0426429af99ad8a2d4d63fe5e8423b33d604 new file mode 100644 index 0000000..f841354 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5e0f0426429af99ad8a2d4d63fe5e8423b33d604 differ diff --git a/fuzz/corpus/alloc_ops/5e268e65ff9b65a7756d3b6e546c74b0f67758ff b/fuzz/corpus/alloc_ops/5e268e65ff9b65a7756d3b6e546c74b0f67758ff new file mode 100644 index 0000000..198679b Binary files /dev/null and b/fuzz/corpus/alloc_ops/5e268e65ff9b65a7756d3b6e546c74b0f67758ff differ diff --git a/fuzz/corpus/alloc_ops/5e3a3e1cbcb3253c660fd7f3d401d5c9304e61f0 b/fuzz/corpus/alloc_ops/5e3a3e1cbcb3253c660fd7f3d401d5c9304e61f0 new file mode 100644 index 0000000..8007fec Binary files /dev/null and b/fuzz/corpus/alloc_ops/5e3a3e1cbcb3253c660fd7f3d401d5c9304e61f0 differ diff --git a/fuzz/corpus/alloc_ops/5e8687c777383fe013c40a68bec0a3b378bd0b1f b/fuzz/corpus/alloc_ops/5e8687c777383fe013c40a68bec0a3b378bd0b1f new file mode 100644 index 0000000..ea37e0b Binary files /dev/null and b/fuzz/corpus/alloc_ops/5e8687c777383fe013c40a68bec0a3b378bd0b1f differ diff --git a/fuzz/corpus/alloc_ops/5eeda1f543506c3e958ae5aba7ccfa24ba381792 b/fuzz/corpus/alloc_ops/5eeda1f543506c3e958ae5aba7ccfa24ba381792 new file mode 100644 index 0000000..b115c30 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5eeda1f543506c3e958ae5aba7ccfa24ba381792 differ diff --git a/fuzz/corpus/alloc_ops/5ef42656a6b1bfa72a5ba66451cb244af304a221 b/fuzz/corpus/alloc_ops/5ef42656a6b1bfa72a5ba66451cb244af304a221 new file mode 100644 index 0000000..abc2092 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5ef42656a6b1bfa72a5ba66451cb244af304a221 differ diff --git a/fuzz/corpus/alloc_ops/5f1f70a93dde77c2458e45c46a3fb62e27d32a88 b/fuzz/corpus/alloc_ops/5f1f70a93dde77c2458e45c46a3fb62e27d32a88 new file mode 100644 index 0000000..bb64804 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f1f70a93dde77c2458e45c46a3fb62e27d32a88 differ diff --git a/fuzz/corpus/alloc_ops/5f2f7de09b937dde76bd2e95a0d83c61f58d2759 b/fuzz/corpus/alloc_ops/5f2f7de09b937dde76bd2e95a0d83c61f58d2759 new file mode 100644 index 0000000..835aece Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f2f7de09b937dde76bd2e95a0d83c61f58d2759 differ diff --git a/fuzz/corpus/alloc_ops/5f511b891a67ccf8b98703433e40efaafaa5a3fe b/fuzz/corpus/alloc_ops/5f511b891a67ccf8b98703433e40efaafaa5a3fe new file mode 100644 index 0000000..7066c88 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f511b891a67ccf8b98703433e40efaafaa5a3fe differ diff --git a/fuzz/corpus/alloc_ops/5f62565f9b4174ee961f197b9a11e3125cc59487 b/fuzz/corpus/alloc_ops/5f62565f9b4174ee961f197b9a11e3125cc59487 new file mode 100644 index 0000000..a489566 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f62565f9b4174ee961f197b9a11e3125cc59487 differ diff --git a/fuzz/corpus/alloc_ops/5f697b460fc9068a5607aadf34096c0e52a9385c b/fuzz/corpus/alloc_ops/5f697b460fc9068a5607aadf34096c0e52a9385c new file mode 100644 index 0000000..95998ee Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f697b460fc9068a5607aadf34096c0e52a9385c differ diff --git a/fuzz/corpus/alloc_ops/5f7d65b7cbb85a56337959ec2d57d6d5471901c1 b/fuzz/corpus/alloc_ops/5f7d65b7cbb85a56337959ec2d57d6d5471901c1 new file mode 100644 index 0000000..d84c088 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5f7d65b7cbb85a56337959ec2d57d6d5471901c1 differ diff --git a/fuzz/corpus/alloc_ops/5fbb0656ab4be41f40cef7a366faf00b73e2ea94 b/fuzz/corpus/alloc_ops/5fbb0656ab4be41f40cef7a366faf00b73e2ea94 new file mode 100644 index 0000000..139c995 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5fbb0656ab4be41f40cef7a366faf00b73e2ea94 differ diff --git a/fuzz/corpus/alloc_ops/5fc6245bb0de248c805f5c8f5ae1745a1342e907 b/fuzz/corpus/alloc_ops/5fc6245bb0de248c805f5c8f5ae1745a1342e907 new file mode 100644 index 0000000..268f593 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5fc6245bb0de248c805f5c8f5ae1745a1342e907 differ diff --git a/fuzz/corpus/alloc_ops/5fdb1711f155a6490808994c330babacdd4327f7 b/fuzz/corpus/alloc_ops/5fdb1711f155a6490808994c330babacdd4327f7 new file mode 100644 index 0000000..f49fce9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/5fdb1711f155a6490808994c330babacdd4327f7 differ diff --git a/fuzz/corpus/alloc_ops/60af6e02c8188d753ad246adfece7cd51880ddc4 b/fuzz/corpus/alloc_ops/60af6e02c8188d753ad246adfece7cd51880ddc4 new file mode 100644 index 0000000..d5af214 Binary files /dev/null and b/fuzz/corpus/alloc_ops/60af6e02c8188d753ad246adfece7cd51880ddc4 differ diff --git a/fuzz/corpus/alloc_ops/60ebc5d5cad8c6a0a5cb98068db3e8c42b17a254 b/fuzz/corpus/alloc_ops/60ebc5d5cad8c6a0a5cb98068db3e8c42b17a254 new file mode 100644 index 0000000..d955730 Binary files /dev/null and b/fuzz/corpus/alloc_ops/60ebc5d5cad8c6a0a5cb98068db3e8c42b17a254 differ diff --git a/fuzz/corpus/alloc_ops/60fd633cf5f30c01a180b3ffd2cb62a8bcc642ef b/fuzz/corpus/alloc_ops/60fd633cf5f30c01a180b3ffd2cb62a8bcc642ef new file mode 100644 index 0000000..8372d6e Binary files /dev/null and b/fuzz/corpus/alloc_ops/60fd633cf5f30c01a180b3ffd2cb62a8bcc642ef differ diff --git a/fuzz/corpus/alloc_ops/61201474527c230d43177aa5d67ef53ddcea241e b/fuzz/corpus/alloc_ops/61201474527c230d43177aa5d67ef53ddcea241e new file mode 100644 index 0000000..bd8dd9a Binary files /dev/null and b/fuzz/corpus/alloc_ops/61201474527c230d43177aa5d67ef53ddcea241e differ diff --git a/fuzz/corpus/alloc_ops/612511108690d10991b75022f5272618340cfeef b/fuzz/corpus/alloc_ops/612511108690d10991b75022f5272618340cfeef new file mode 100644 index 0000000..cba6931 Binary files /dev/null and b/fuzz/corpus/alloc_ops/612511108690d10991b75022f5272618340cfeef differ diff --git a/fuzz/corpus/alloc_ops/615769c43a12ca10b0372428b03ada23945a019c b/fuzz/corpus/alloc_ops/615769c43a12ca10b0372428b03ada23945a019c new file mode 100644 index 0000000..a98457b Binary files /dev/null and b/fuzz/corpus/alloc_ops/615769c43a12ca10b0372428b03ada23945a019c differ diff --git a/fuzz/corpus/alloc_ops/6173da5673fcd4af676fe041fdc6b55c15102886 b/fuzz/corpus/alloc_ops/6173da5673fcd4af676fe041fdc6b55c15102886 new file mode 100644 index 0000000..fe626f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6173da5673fcd4af676fe041fdc6b55c15102886 differ diff --git a/fuzz/corpus/alloc_ops/61c0d772ce98f3de49085563433d506cf8a622c2 b/fuzz/corpus/alloc_ops/61c0d772ce98f3de49085563433d506cf8a622c2 new file mode 100644 index 0000000..e32f321 Binary files /dev/null and b/fuzz/corpus/alloc_ops/61c0d772ce98f3de49085563433d506cf8a622c2 differ diff --git a/fuzz/corpus/alloc_ops/61c546806ab6c8471b2f58f4ebdafb705a7dd03d b/fuzz/corpus/alloc_ops/61c546806ab6c8471b2f58f4ebdafb705a7dd03d new file mode 100644 index 0000000..54fef93 Binary files /dev/null and b/fuzz/corpus/alloc_ops/61c546806ab6c8471b2f58f4ebdafb705a7dd03d differ diff --git a/fuzz/corpus/alloc_ops/62223085306a6328f3a97a87ea3b5344a18dac32 b/fuzz/corpus/alloc_ops/62223085306a6328f3a97a87ea3b5344a18dac32 new file mode 100644 index 0000000..f648ba5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/62223085306a6328f3a97a87ea3b5344a18dac32 differ diff --git a/fuzz/corpus/alloc_ops/624729c874ad3b17e3b08f808f3853934c083f62 b/fuzz/corpus/alloc_ops/624729c874ad3b17e3b08f808f3853934c083f62 new file mode 100644 index 0000000..37196a7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/624729c874ad3b17e3b08f808f3853934c083f62 differ diff --git a/fuzz/corpus/alloc_ops/625e950d0cd0a0b8f0a016a32820f2b9e5b60302 b/fuzz/corpus/alloc_ops/625e950d0cd0a0b8f0a016a32820f2b9e5b60302 new file mode 100644 index 0000000..4de535b Binary files /dev/null and b/fuzz/corpus/alloc_ops/625e950d0cd0a0b8f0a016a32820f2b9e5b60302 differ diff --git a/fuzz/corpus/alloc_ops/6292d17d6a4ae88c19eadd019e5617331fd9303f b/fuzz/corpus/alloc_ops/6292d17d6a4ae88c19eadd019e5617331fd9303f new file mode 100644 index 0000000..ead77fd Binary files /dev/null and b/fuzz/corpus/alloc_ops/6292d17d6a4ae88c19eadd019e5617331fd9303f differ diff --git a/fuzz/corpus/alloc_ops/629e470fd0e6d16443220f66a00fae19e3d21cb2 b/fuzz/corpus/alloc_ops/629e470fd0e6d16443220f66a00fae19e3d21cb2 new file mode 100644 index 0000000..f45b69c Binary files /dev/null and b/fuzz/corpus/alloc_ops/629e470fd0e6d16443220f66a00fae19e3d21cb2 differ diff --git a/fuzz/corpus/alloc_ops/62a7839459a69b6657c64857a808cfb0c8d28094 b/fuzz/corpus/alloc_ops/62a7839459a69b6657c64857a808cfb0c8d28094 new file mode 100644 index 0000000..4fd9dce Binary files /dev/null and b/fuzz/corpus/alloc_ops/62a7839459a69b6657c64857a808cfb0c8d28094 differ diff --git a/fuzz/corpus/alloc_ops/62b5bc6dd938fb6c4a752d5e693126ce10dad094 b/fuzz/corpus/alloc_ops/62b5bc6dd938fb6c4a752d5e693126ce10dad094 new file mode 100644 index 0000000..154abe3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/62b5bc6dd938fb6c4a752d5e693126ce10dad094 differ diff --git a/fuzz/corpus/alloc_ops/62ba3c04e56cd6bc244921bb50ab61e0d7cc1dcd b/fuzz/corpus/alloc_ops/62ba3c04e56cd6bc244921bb50ab61e0d7cc1dcd new file mode 100644 index 0000000..b2cf168 Binary files /dev/null and b/fuzz/corpus/alloc_ops/62ba3c04e56cd6bc244921bb50ab61e0d7cc1dcd differ diff --git a/fuzz/corpus/alloc_ops/62c86744a3a5d47f1ecb927451f829c1ead1f632 b/fuzz/corpus/alloc_ops/62c86744a3a5d47f1ecb927451f829c1ead1f632 new file mode 100644 index 0000000..0c07951 Binary files /dev/null and b/fuzz/corpus/alloc_ops/62c86744a3a5d47f1ecb927451f829c1ead1f632 differ diff --git a/fuzz/corpus/alloc_ops/6312a31a238a6cef68ba986d97d2f06631147a2d b/fuzz/corpus/alloc_ops/6312a31a238a6cef68ba986d97d2f06631147a2d new file mode 100644 index 0000000..d107d8e Binary files /dev/null and b/fuzz/corpus/alloc_ops/6312a31a238a6cef68ba986d97d2f06631147a2d differ diff --git a/fuzz/corpus/alloc_ops/63490e5a7de8d74d820fc47fd70ce554c6b44655 b/fuzz/corpus/alloc_ops/63490e5a7de8d74d820fc47fd70ce554c6b44655 new file mode 100644 index 0000000..1527b60 Binary files /dev/null and b/fuzz/corpus/alloc_ops/63490e5a7de8d74d820fc47fd70ce554c6b44655 differ diff --git a/fuzz/corpus/alloc_ops/637ff50aeb4bc92a7846037f18e646a58603e376 b/fuzz/corpus/alloc_ops/637ff50aeb4bc92a7846037f18e646a58603e376 new file mode 100644 index 0000000..c026c54 Binary files /dev/null and b/fuzz/corpus/alloc_ops/637ff50aeb4bc92a7846037f18e646a58603e376 differ diff --git a/fuzz/corpus/alloc_ops/63825fa91e910b3af49775038b6a87a3949b89cf b/fuzz/corpus/alloc_ops/63825fa91e910b3af49775038b6a87a3949b89cf new file mode 100644 index 0000000..8b889fb Binary files /dev/null and b/fuzz/corpus/alloc_ops/63825fa91e910b3af49775038b6a87a3949b89cf differ diff --git a/fuzz/corpus/alloc_ops/63aa8159eeaab34e66a6d08989e7f36c374c9a9c b/fuzz/corpus/alloc_ops/63aa8159eeaab34e66a6d08989e7f36c374c9a9c new file mode 100644 index 0000000..b8da2f3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/63aa8159eeaab34e66a6d08989e7f36c374c9a9c differ diff --git a/fuzz/corpus/alloc_ops/63ca73518e74b8bfe6d99bcdbc0a603f4101254d b/fuzz/corpus/alloc_ops/63ca73518e74b8bfe6d99bcdbc0a603f4101254d new file mode 100644 index 0000000..51e0810 --- /dev/null +++ b/fuzz/corpus/alloc_ops/63ca73518e74b8bfe6d99bcdbc0a603f4101254d @@ -0,0 +1 @@ +¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬²¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬ÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁ¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/63dfa017dfabfc69819819ac21dd7ca058d1936c b/fuzz/corpus/alloc_ops/63dfa017dfabfc69819819ac21dd7ca058d1936c new file mode 100644 index 0000000..15ba682 Binary files /dev/null and b/fuzz/corpus/alloc_ops/63dfa017dfabfc69819819ac21dd7ca058d1936c differ diff --git a/fuzz/corpus/alloc_ops/63ec1d27d8bb169fa2aeb758d093f073a4e4fac4 b/fuzz/corpus/alloc_ops/63ec1d27d8bb169fa2aeb758d093f073a4e4fac4 new file mode 100644 index 0000000..45cd6e2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/63ec1d27d8bb169fa2aeb758d093f073a4e4fac4 differ diff --git a/fuzz/corpus/alloc_ops/6410bfef08df17532a64aa381af6c8afa3415e6a b/fuzz/corpus/alloc_ops/6410bfef08df17532a64aa381af6c8afa3415e6a new file mode 100644 index 0000000..6d5e475 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6410bfef08df17532a64aa381af6c8afa3415e6a differ diff --git a/fuzz/corpus/alloc_ops/641d39367d328da4d4a963d9a0c56a6074ade22d b/fuzz/corpus/alloc_ops/641d39367d328da4d4a963d9a0c56a6074ade22d new file mode 100644 index 0000000..8a8f7e7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/641d39367d328da4d4a963d9a0c56a6074ade22d differ diff --git a/fuzz/corpus/alloc_ops/649df338448f18c12a9816e163189017af617d7f b/fuzz/corpus/alloc_ops/649df338448f18c12a9816e163189017af617d7f new file mode 100644 index 0000000..a0c1b33 Binary files /dev/null and b/fuzz/corpus/alloc_ops/649df338448f18c12a9816e163189017af617d7f differ diff --git a/fuzz/corpus/alloc_ops/64c5bf7da14a6c8a38a2daca21ca7b38bb9d6c99 b/fuzz/corpus/alloc_ops/64c5bf7da14a6c8a38a2daca21ca7b38bb9d6c99 new file mode 100644 index 0000000..d5db8b4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/64c5bf7da14a6c8a38a2daca21ca7b38bb9d6c99 differ diff --git a/fuzz/corpus/alloc_ops/64c6fbdad1c032af3697f74aa0d4e3d659c6b963 b/fuzz/corpus/alloc_ops/64c6fbdad1c032af3697f74aa0d4e3d659c6b963 new file mode 100644 index 0000000..37db530 Binary files /dev/null and b/fuzz/corpus/alloc_ops/64c6fbdad1c032af3697f74aa0d4e3d659c6b963 differ diff --git a/fuzz/corpus/alloc_ops/64e82eb21278282707f3c1f00ae8736588726c77 b/fuzz/corpus/alloc_ops/64e82eb21278282707f3c1f00ae8736588726c77 new file mode 100644 index 0000000..ad89e86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/64e82eb21278282707f3c1f00ae8736588726c77 differ diff --git a/fuzz/corpus/alloc_ops/6505aeab208b8eddc7c571fdbe2133d0408ea8c5 b/fuzz/corpus/alloc_ops/6505aeab208b8eddc7c571fdbe2133d0408ea8c5 new file mode 100644 index 0000000..c8ac35e Binary files /dev/null and b/fuzz/corpus/alloc_ops/6505aeab208b8eddc7c571fdbe2133d0408ea8c5 differ diff --git a/fuzz/corpus/alloc_ops/650f9b664879e12915247a3854723a1df78b95f7 b/fuzz/corpus/alloc_ops/650f9b664879e12915247a3854723a1df78b95f7 new file mode 100644 index 0000000..755e972 Binary files /dev/null and b/fuzz/corpus/alloc_ops/650f9b664879e12915247a3854723a1df78b95f7 differ diff --git a/fuzz/corpus/alloc_ops/6516e7733c5961a97bc022a7b898510c0697cdc8 b/fuzz/corpus/alloc_ops/6516e7733c5961a97bc022a7b898510c0697cdc8 new file mode 100644 index 0000000..010262e Binary files /dev/null and b/fuzz/corpus/alloc_ops/6516e7733c5961a97bc022a7b898510c0697cdc8 differ diff --git a/fuzz/corpus/alloc_ops/653ff76c076b7fc4784f0631d8350f67c3fe42dd b/fuzz/corpus/alloc_ops/653ff76c076b7fc4784f0631d8350f67c3fe42dd new file mode 100644 index 0000000..f7abfec Binary files /dev/null and b/fuzz/corpus/alloc_ops/653ff76c076b7fc4784f0631d8350f67c3fe42dd differ diff --git a/fuzz/corpus/alloc_ops/656eb7263fe71769370c07d1f6a19af8dfddff0f b/fuzz/corpus/alloc_ops/656eb7263fe71769370c07d1f6a19af8dfddff0f new file mode 100644 index 0000000..e1abbfd Binary files /dev/null and b/fuzz/corpus/alloc_ops/656eb7263fe71769370c07d1f6a19af8dfddff0f differ diff --git a/fuzz/corpus/alloc_ops/6574383071bf9be6ddc201a566bd380d003ae41d b/fuzz/corpus/alloc_ops/6574383071bf9be6ddc201a566bd380d003ae41d new file mode 100644 index 0000000..f179fe3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6574383071bf9be6ddc201a566bd380d003ae41d differ diff --git a/fuzz/corpus/alloc_ops/659f51285e4237050aa62ff4dee6f0a5dba32cbd b/fuzz/corpus/alloc_ops/659f51285e4237050aa62ff4dee6f0a5dba32cbd new file mode 100644 index 0000000..a0fddd6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/659f51285e4237050aa62ff4dee6f0a5dba32cbd differ diff --git a/fuzz/corpus/alloc_ops/65f50dcadfdb01aa0cdce745addc30a28735bb4f b/fuzz/corpus/alloc_ops/65f50dcadfdb01aa0cdce745addc30a28735bb4f new file mode 100644 index 0000000..c24c5da Binary files /dev/null and b/fuzz/corpus/alloc_ops/65f50dcadfdb01aa0cdce745addc30a28735bb4f differ diff --git a/fuzz/corpus/alloc_ops/663f298fe28be0bffaf9d3355e8927cf09ee0501 b/fuzz/corpus/alloc_ops/663f298fe28be0bffaf9d3355e8927cf09ee0501 new file mode 100644 index 0000000..1f6dc72 Binary files /dev/null and b/fuzz/corpus/alloc_ops/663f298fe28be0bffaf9d3355e8927cf09ee0501 differ diff --git a/fuzz/corpus/alloc_ops/66616c1c704baa95d4688e8071e5163c517c3673 b/fuzz/corpus/alloc_ops/66616c1c704baa95d4688e8071e5163c517c3673 new file mode 100644 index 0000000..137ef7f Binary files /dev/null and b/fuzz/corpus/alloc_ops/66616c1c704baa95d4688e8071e5163c517c3673 differ diff --git a/fuzz/corpus/alloc_ops/666277ebeda8ff57518d6ba557a6c6f69f429c41 b/fuzz/corpus/alloc_ops/666277ebeda8ff57518d6ba557a6c6f69f429c41 new file mode 100644 index 0000000..e50306a Binary files /dev/null and b/fuzz/corpus/alloc_ops/666277ebeda8ff57518d6ba557a6c6f69f429c41 differ diff --git a/fuzz/corpus/alloc_ops/668b681a03120f898f410ac982680ee489803706 b/fuzz/corpus/alloc_ops/668b681a03120f898f410ac982680ee489803706 new file mode 100644 index 0000000..e1b5e60 Binary files /dev/null and b/fuzz/corpus/alloc_ops/668b681a03120f898f410ac982680ee489803706 differ diff --git a/fuzz/corpus/alloc_ops/669b484497bcec6faf4c2750f74ebd441eb5d1e9 b/fuzz/corpus/alloc_ops/669b484497bcec6faf4c2750f74ebd441eb5d1e9 new file mode 100644 index 0000000..e33d66e --- /dev/null +++ b/fuzz/corpus/alloc_ops/669b484497bcec6faf4c2750f74ebd441eb5d1e9 @@ -0,0 +1 @@ +SÿEÿŒr#ÿ,C \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/66a013bdcd89c1c1590d10d87da5eafe8ee92c9e b/fuzz/corpus/alloc_ops/66a013bdcd89c1c1590d10d87da5eafe8ee92c9e new file mode 100644 index 0000000..dad745a Binary files /dev/null and b/fuzz/corpus/alloc_ops/66a013bdcd89c1c1590d10d87da5eafe8ee92c9e differ diff --git a/fuzz/corpus/alloc_ops/66bcab9491eef4c1e9b8a0ef1b51f6f199762e57 b/fuzz/corpus/alloc_ops/66bcab9491eef4c1e9b8a0ef1b51f6f199762e57 new file mode 100644 index 0000000..17dff91 Binary files /dev/null and b/fuzz/corpus/alloc_ops/66bcab9491eef4c1e9b8a0ef1b51f6f199762e57 differ diff --git a/fuzz/corpus/alloc_ops/66cc428ea177be31b96c5600d291a72242e7b411 b/fuzz/corpus/alloc_ops/66cc428ea177be31b96c5600d291a72242e7b411 new file mode 100644 index 0000000..0cec191 Binary files /dev/null and b/fuzz/corpus/alloc_ops/66cc428ea177be31b96c5600d291a72242e7b411 differ diff --git a/fuzz/corpus/alloc_ops/670fc4db2f67607139a851b90ef7f540a3d8e7df b/fuzz/corpus/alloc_ops/670fc4db2f67607139a851b90ef7f540a3d8e7df new file mode 100644 index 0000000..74d7f05 Binary files /dev/null and b/fuzz/corpus/alloc_ops/670fc4db2f67607139a851b90ef7f540a3d8e7df differ diff --git a/fuzz/corpus/alloc_ops/67337e26e30846a97a900aa7a5f63be8a1c8459f b/fuzz/corpus/alloc_ops/67337e26e30846a97a900aa7a5f63be8a1c8459f new file mode 100644 index 0000000..a76060e Binary files /dev/null and b/fuzz/corpus/alloc_ops/67337e26e30846a97a900aa7a5f63be8a1c8459f differ diff --git a/fuzz/corpus/alloc_ops/673647985afd5d7b7acfd5783cbc45c567a55724 b/fuzz/corpus/alloc_ops/673647985afd5d7b7acfd5783cbc45c567a55724 new file mode 100644 index 0000000..970f85e Binary files /dev/null and b/fuzz/corpus/alloc_ops/673647985afd5d7b7acfd5783cbc45c567a55724 differ diff --git a/fuzz/corpus/alloc_ops/674013f13a083f0e51c49163cfc50f7c88ddd2bd b/fuzz/corpus/alloc_ops/674013f13a083f0e51c49163cfc50f7c88ddd2bd new file mode 100644 index 0000000..21e7059 Binary files /dev/null and b/fuzz/corpus/alloc_ops/674013f13a083f0e51c49163cfc50f7c88ddd2bd differ diff --git a/fuzz/corpus/alloc_ops/6773a8033e52c5d6e5a1de38286113f292cce473 b/fuzz/corpus/alloc_ops/6773a8033e52c5d6e5a1de38286113f292cce473 new file mode 100644 index 0000000..4ff3854 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6773a8033e52c5d6e5a1de38286113f292cce473 differ diff --git a/fuzz/corpus/alloc_ops/67a259b7fb32b3f971be06c1690cac838c49fa4b b/fuzz/corpus/alloc_ops/67a259b7fb32b3f971be06c1690cac838c49fa4b new file mode 100644 index 0000000..9dff96b Binary files /dev/null and b/fuzz/corpus/alloc_ops/67a259b7fb32b3f971be06c1690cac838c49fa4b differ diff --git a/fuzz/corpus/alloc_ops/67cd52371893c2df7c989199d55cd6a7898d4939 b/fuzz/corpus/alloc_ops/67cd52371893c2df7c989199d55cd6a7898d4939 new file mode 100644 index 0000000..343da11 Binary files /dev/null and b/fuzz/corpus/alloc_ops/67cd52371893c2df7c989199d55cd6a7898d4939 differ diff --git a/fuzz/corpus/alloc_ops/67d02b16c66a02ca1e0b47094e0fb9c6a661d100 b/fuzz/corpus/alloc_ops/67d02b16c66a02ca1e0b47094e0fb9c6a661d100 new file mode 100644 index 0000000..693e8a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/67d02b16c66a02ca1e0b47094e0fb9c6a661d100 differ diff --git a/fuzz/corpus/alloc_ops/67fc87c26d3d7cc0f4b4b34bed9891cbe59f3ffd b/fuzz/corpus/alloc_ops/67fc87c26d3d7cc0f4b4b34bed9891cbe59f3ffd new file mode 100644 index 0000000..36dce93 Binary files /dev/null and b/fuzz/corpus/alloc_ops/67fc87c26d3d7cc0f4b4b34bed9891cbe59f3ffd differ diff --git a/fuzz/corpus/alloc_ops/68435f2f2913e60ead6b89d72c5a6de054f42457 b/fuzz/corpus/alloc_ops/68435f2f2913e60ead6b89d72c5a6de054f42457 new file mode 100644 index 0000000..3ca5c46 Binary files /dev/null and b/fuzz/corpus/alloc_ops/68435f2f2913e60ead6b89d72c5a6de054f42457 differ diff --git a/fuzz/corpus/alloc_ops/687fb9425f95b32ea9c77d522cce9c3c3ed616d9 b/fuzz/corpus/alloc_ops/687fb9425f95b32ea9c77d522cce9c3c3ed616d9 new file mode 100644 index 0000000..5e66224 Binary files /dev/null and b/fuzz/corpus/alloc_ops/687fb9425f95b32ea9c77d522cce9c3c3ed616d9 differ diff --git a/fuzz/corpus/alloc_ops/688057090146c25e83185c61c75f569d001b1c85 b/fuzz/corpus/alloc_ops/688057090146c25e83185c61c75f569d001b1c85 new file mode 100644 index 0000000..80c7c6f Binary files /dev/null and b/fuzz/corpus/alloc_ops/688057090146c25e83185c61c75f569d001b1c85 differ diff --git a/fuzz/corpus/alloc_ops/69543c6a7e82ce6402c848a85521738b5ce443d6 b/fuzz/corpus/alloc_ops/69543c6a7e82ce6402c848a85521738b5ce443d6 new file mode 100644 index 0000000..95516b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/69543c6a7e82ce6402c848a85521738b5ce443d6 differ diff --git a/fuzz/corpus/alloc_ops/69b0ec880b34ddb67e93d6b24a22085afafe982b b/fuzz/corpus/alloc_ops/69b0ec880b34ddb67e93d6b24a22085afafe982b new file mode 100644 index 0000000..b8008ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/69b0ec880b34ddb67e93d6b24a22085afafe982b differ diff --git a/fuzz/corpus/alloc_ops/69cd6d12af4e6f20e478d666e7b1d1e49b46026d b/fuzz/corpus/alloc_ops/69cd6d12af4e6f20e478d666e7b1d1e49b46026d new file mode 100644 index 0000000..067e2cc Binary files /dev/null and b/fuzz/corpus/alloc_ops/69cd6d12af4e6f20e478d666e7b1d1e49b46026d differ diff --git a/fuzz/corpus/alloc_ops/69d7090a146e47b407323cd5b140bf599164b982 b/fuzz/corpus/alloc_ops/69d7090a146e47b407323cd5b140bf599164b982 new file mode 100644 index 0000000..bb36fa6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/69d7090a146e47b407323cd5b140bf599164b982 differ diff --git a/fuzz/corpus/alloc_ops/69d7b4e0a6d44071ac37a7efdbb09f486a41f504 b/fuzz/corpus/alloc_ops/69d7b4e0a6d44071ac37a7efdbb09f486a41f504 new file mode 100644 index 0000000..ecef181 Binary files /dev/null and b/fuzz/corpus/alloc_ops/69d7b4e0a6d44071ac37a7efdbb09f486a41f504 differ diff --git a/fuzz/corpus/alloc_ops/69e02fb7523a8ed03f10e3a3c6bee516b5e6fb60 b/fuzz/corpus/alloc_ops/69e02fb7523a8ed03f10e3a3c6bee516b5e6fb60 new file mode 100644 index 0000000..98ed404 Binary files /dev/null and b/fuzz/corpus/alloc_ops/69e02fb7523a8ed03f10e3a3c6bee516b5e6fb60 differ diff --git a/fuzz/corpus/alloc_ops/69e4eda04aa5477f5365e60c6a2130b7541859a6 b/fuzz/corpus/alloc_ops/69e4eda04aa5477f5365e60c6a2130b7541859a6 new file mode 100644 index 0000000..170fc4e --- /dev/null +++ b/fuzz/corpus/alloc_ops/69e4eda04aa5477f5365e60c6a2130b7541859a6 @@ -0,0 +1,2 @@ +&r +;$r; \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/6a3f164732bfe27d6e63c81925f23192a76bbb06 b/fuzz/corpus/alloc_ops/6a3f164732bfe27d6e63c81925f23192a76bbb06 new file mode 100644 index 0000000..69b6597 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6a3f164732bfe27d6e63c81925f23192a76bbb06 differ diff --git a/fuzz/corpus/alloc_ops/6aa05ddce8ae5611d49304c28bb09a94d1a15a20 b/fuzz/corpus/alloc_ops/6aa05ddce8ae5611d49304c28bb09a94d1a15a20 new file mode 100644 index 0000000..80238c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6aa05ddce8ae5611d49304c28bb09a94d1a15a20 differ diff --git a/fuzz/corpus/alloc_ops/6aa1c6a99f4cc99dac59d5a89aff740289a90d02 b/fuzz/corpus/alloc_ops/6aa1c6a99f4cc99dac59d5a89aff740289a90d02 new file mode 100644 index 0000000..b72edac Binary files /dev/null and b/fuzz/corpus/alloc_ops/6aa1c6a99f4cc99dac59d5a89aff740289a90d02 differ diff --git a/fuzz/corpus/alloc_ops/6abbd88c349b7431065b95adefac3b3c6a832163 b/fuzz/corpus/alloc_ops/6abbd88c349b7431065b95adefac3b3c6a832163 new file mode 100644 index 0000000..76d37c4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6abbd88c349b7431065b95adefac3b3c6a832163 differ diff --git a/fuzz/corpus/alloc_ops/6abd6e55be6b2bff2cb91b2065f41ecb7b9e2bfe b/fuzz/corpus/alloc_ops/6abd6e55be6b2bff2cb91b2065f41ecb7b9e2bfe new file mode 100644 index 0000000..34c7886 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6abd6e55be6b2bff2cb91b2065f41ecb7b9e2bfe differ diff --git a/fuzz/corpus/alloc_ops/6b13e69e8e7928a3144511002e6514c6be0a3376 b/fuzz/corpus/alloc_ops/6b13e69e8e7928a3144511002e6514c6be0a3376 new file mode 100644 index 0000000..a597c5e Binary files /dev/null and b/fuzz/corpus/alloc_ops/6b13e69e8e7928a3144511002e6514c6be0a3376 differ diff --git a/fuzz/corpus/alloc_ops/6b1a070bf33f170bff3ecbe580c75b1a29174c13 b/fuzz/corpus/alloc_ops/6b1a070bf33f170bff3ecbe580c75b1a29174c13 new file mode 100644 index 0000000..662aaae Binary files /dev/null and b/fuzz/corpus/alloc_ops/6b1a070bf33f170bff3ecbe580c75b1a29174c13 differ diff --git a/fuzz/corpus/alloc_ops/6b6aff024ba5bc9761a7b6ace6f2f2066bd39c3e b/fuzz/corpus/alloc_ops/6b6aff024ba5bc9761a7b6ace6f2f2066bd39c3e new file mode 100644 index 0000000..077216d Binary files /dev/null and b/fuzz/corpus/alloc_ops/6b6aff024ba5bc9761a7b6ace6f2f2066bd39c3e differ diff --git a/fuzz/corpus/alloc_ops/6bae8d8efdc5119a9cd6a90fca608dd2dd615fc4 b/fuzz/corpus/alloc_ops/6bae8d8efdc5119a9cd6a90fca608dd2dd615fc4 new file mode 100644 index 0000000..cc5c5ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/6bae8d8efdc5119a9cd6a90fca608dd2dd615fc4 differ diff --git a/fuzz/corpus/alloc_ops/6bd6ac7869effeb15c94136339ed706e7dfa6f29 b/fuzz/corpus/alloc_ops/6bd6ac7869effeb15c94136339ed706e7dfa6f29 new file mode 100644 index 0000000..c01f495 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6bd6ac7869effeb15c94136339ed706e7dfa6f29 differ diff --git a/fuzz/corpus/alloc_ops/6bda2c4dbdbf0c8b73f926e4d33ab1d2ea35eaf5 b/fuzz/corpus/alloc_ops/6bda2c4dbdbf0c8b73f926e4d33ab1d2ea35eaf5 new file mode 100644 index 0000000..442cc86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6bda2c4dbdbf0c8b73f926e4d33ab1d2ea35eaf5 differ diff --git a/fuzz/corpus/alloc_ops/6bf85258915d82e7db96c1d54d5037e66931b470 b/fuzz/corpus/alloc_ops/6bf85258915d82e7db96c1d54d5037e66931b470 new file mode 100644 index 0000000..f4f1b12 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6bf85258915d82e7db96c1d54d5037e66931b470 differ diff --git a/fuzz/corpus/alloc_ops/6cf3c201434ecdeb5a7cd6765974a557c958e0d3 b/fuzz/corpus/alloc_ops/6cf3c201434ecdeb5a7cd6765974a557c958e0d3 new file mode 100644 index 0000000..29277d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6cf3c201434ecdeb5a7cd6765974a557c958e0d3 differ diff --git a/fuzz/corpus/alloc_ops/6d42b95d35862acf299c7b24c253fefcdf93c52e b/fuzz/corpus/alloc_ops/6d42b95d35862acf299c7b24c253fefcdf93c52e new file mode 100644 index 0000000..63c685c Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d42b95d35862acf299c7b24c253fefcdf93c52e differ diff --git a/fuzz/corpus/alloc_ops/6d62f4007fff30c6ff247fda4b4ca92b21956e4c b/fuzz/corpus/alloc_ops/6d62f4007fff30c6ff247fda4b4ca92b21956e4c new file mode 100644 index 0000000..99ccb9e Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d62f4007fff30c6ff247fda4b4ca92b21956e4c differ diff --git a/fuzz/corpus/alloc_ops/6d673f22c8ef107a9c9296dfb68aab42a888cc2d b/fuzz/corpus/alloc_ops/6d673f22c8ef107a9c9296dfb68aab42a888cc2d new file mode 100644 index 0000000..d82fb66 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d673f22c8ef107a9c9296dfb68aab42a888cc2d differ diff --git a/fuzz/corpus/alloc_ops/6d6dad629acd9fb54efcc20e0906177a9180a473 b/fuzz/corpus/alloc_ops/6d6dad629acd9fb54efcc20e0906177a9180a473 new file mode 100644 index 0000000..91dd417 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d6dad629acd9fb54efcc20e0906177a9180a473 differ diff --git a/fuzz/corpus/alloc_ops/6d73243101061191fb8070ca5d33dc005a25458a b/fuzz/corpus/alloc_ops/6d73243101061191fb8070ca5d33dc005a25458a new file mode 100644 index 0000000..7e39c72 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d73243101061191fb8070ca5d33dc005a25458a differ diff --git a/fuzz/corpus/alloc_ops/6d78f4675f015857977b1a694d2d009e02803c20 b/fuzz/corpus/alloc_ops/6d78f4675f015857977b1a694d2d009e02803c20 new file mode 100644 index 0000000..7c5d20b Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d78f4675f015857977b1a694d2d009e02803c20 differ diff --git a/fuzz/corpus/alloc_ops/6d82fb22e5eae986fc06eecaf6073bb18ce4c400 b/fuzz/corpus/alloc_ops/6d82fb22e5eae986fc06eecaf6073bb18ce4c400 new file mode 100644 index 0000000..c193431 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d82fb22e5eae986fc06eecaf6073bb18ce4c400 differ diff --git a/fuzz/corpus/alloc_ops/6d91b7291ca5c622d698737f3669f6f1c9fe947a b/fuzz/corpus/alloc_ops/6d91b7291ca5c622d698737f3669f6f1c9fe947a new file mode 100644 index 0000000..c496235 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6d91b7291ca5c622d698737f3669f6f1c9fe947a differ diff --git a/fuzz/corpus/alloc_ops/6dc568d1aa7cf02280ea3f64b623f10350c6ee36 b/fuzz/corpus/alloc_ops/6dc568d1aa7cf02280ea3f64b623f10350c6ee36 new file mode 100644 index 0000000..2d518e1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6dc568d1aa7cf02280ea3f64b623f10350c6ee36 differ diff --git a/fuzz/corpus/alloc_ops/6e4d78447d6250b8c05750d94bd3c919594db9e7 b/fuzz/corpus/alloc_ops/6e4d78447d6250b8c05750d94bd3c919594db9e7 new file mode 100644 index 0000000..67b4ec9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6e4d78447d6250b8c05750d94bd3c919594db9e7 differ diff --git a/fuzz/corpus/alloc_ops/6e528da164612247682d317a513f8465863df4c8 b/fuzz/corpus/alloc_ops/6e528da164612247682d317a513f8465863df4c8 new file mode 100644 index 0000000..5dca2b7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6e528da164612247682d317a513f8465863df4c8 differ diff --git a/fuzz/corpus/alloc_ops/6e5efe8e6b6a43a49aa074a2be31964f02d04698 b/fuzz/corpus/alloc_ops/6e5efe8e6b6a43a49aa074a2be31964f02d04698 new file mode 100644 index 0000000..c6ad161 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6e5efe8e6b6a43a49aa074a2be31964f02d04698 differ diff --git a/fuzz/corpus/alloc_ops/6e79523558ca5670ac5e74713ccf7f8e00b29583 b/fuzz/corpus/alloc_ops/6e79523558ca5670ac5e74713ccf7f8e00b29583 new file mode 100644 index 0000000..51c26ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/6e79523558ca5670ac5e74713ccf7f8e00b29583 differ diff --git a/fuzz/corpus/alloc_ops/6ea7d6a33ce0327cb6338f5fcce0024c3df5e3c5 b/fuzz/corpus/alloc_ops/6ea7d6a33ce0327cb6338f5fcce0024c3df5e3c5 new file mode 100644 index 0000000..b353fb2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6ea7d6a33ce0327cb6338f5fcce0024c3df5e3c5 differ diff --git a/fuzz/corpus/alloc_ops/6f2809685c3481b77d75a565383f9e71de03d937 b/fuzz/corpus/alloc_ops/6f2809685c3481b77d75a565383f9e71de03d937 new file mode 100644 index 0000000..5a58f6c Binary files /dev/null and b/fuzz/corpus/alloc_ops/6f2809685c3481b77d75a565383f9e71de03d937 differ diff --git a/fuzz/corpus/alloc_ops/6f305ce1979ceb117a982e9c970ccf392874869b b/fuzz/corpus/alloc_ops/6f305ce1979ceb117a982e9c970ccf392874869b new file mode 100644 index 0000000..e0b7106 Binary files /dev/null and b/fuzz/corpus/alloc_ops/6f305ce1979ceb117a982e9c970ccf392874869b differ diff --git a/fuzz/corpus/alloc_ops/6fe8cf28e5d1f664246e4eb686d5e2d88a89d7fb b/fuzz/corpus/alloc_ops/6fe8cf28e5d1f664246e4eb686d5e2d88a89d7fb new file mode 100644 index 0000000..548568c Binary files /dev/null and b/fuzz/corpus/alloc_ops/6fe8cf28e5d1f664246e4eb686d5e2d88a89d7fb differ diff --git a/fuzz/corpus/alloc_ops/70013fbfd3b53772794606f8aabc5120467ee616 b/fuzz/corpus/alloc_ops/70013fbfd3b53772794606f8aabc5120467ee616 new file mode 100644 index 0000000..ca9a8ef Binary files /dev/null and b/fuzz/corpus/alloc_ops/70013fbfd3b53772794606f8aabc5120467ee616 differ diff --git a/fuzz/corpus/alloc_ops/700da4c7c13beac896ec3b1338bec6a583c92be1 b/fuzz/corpus/alloc_ops/700da4c7c13beac896ec3b1338bec6a583c92be1 new file mode 100644 index 0000000..521c6f6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/700da4c7c13beac896ec3b1338bec6a583c92be1 differ diff --git a/fuzz/corpus/alloc_ops/7067b29b1c56cc4059083395dda9933a1b4344e6 b/fuzz/corpus/alloc_ops/7067b29b1c56cc4059083395dda9933a1b4344e6 new file mode 100644 index 0000000..f016482 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7067b29b1c56cc4059083395dda9933a1b4344e6 differ diff --git a/fuzz/corpus/alloc_ops/7072453e7f736597ce2860f32e6e00c19af334ed b/fuzz/corpus/alloc_ops/7072453e7f736597ce2860f32e6e00c19af334ed new file mode 100644 index 0000000..e5a5e08 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7072453e7f736597ce2860f32e6e00c19af334ed differ diff --git a/fuzz/corpus/alloc_ops/708a058d97024ec248e690224b707cc4dad59247 b/fuzz/corpus/alloc_ops/708a058d97024ec248e690224b707cc4dad59247 new file mode 100644 index 0000000..06a6946 --- /dev/null +++ b/fuzz/corpus/alloc_ops/708a058d97024ec248e690224b707cc4dad59247 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/70aea2adf3aee0f3e89b96bd9273a943665f572c b/fuzz/corpus/alloc_ops/70aea2adf3aee0f3e89b96bd9273a943665f572c new file mode 100644 index 0000000..5f6e49c Binary files /dev/null and b/fuzz/corpus/alloc_ops/70aea2adf3aee0f3e89b96bd9273a943665f572c differ diff --git a/fuzz/corpus/alloc_ops/70cfccf9d2d9b36246566eb77f5905d49d85bfe6 b/fuzz/corpus/alloc_ops/70cfccf9d2d9b36246566eb77f5905d49d85bfe6 new file mode 100644 index 0000000..26ed632 --- /dev/null +++ b/fuzz/corpus/alloc_ops/70cfccf9d2d9b36246566eb77f5905d49d85bfe6 @@ -0,0 +1 @@ +{µ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/71021c3ab9fba5116f4fe103ac53919a72ff2ceb b/fuzz/corpus/alloc_ops/71021c3ab9fba5116f4fe103ac53919a72ff2ceb new file mode 100644 index 0000000..4bd033f Binary files /dev/null and b/fuzz/corpus/alloc_ops/71021c3ab9fba5116f4fe103ac53919a72ff2ceb differ diff --git a/fuzz/corpus/alloc_ops/71788f8d79e74c034adc80538f292315d71737e0 b/fuzz/corpus/alloc_ops/71788f8d79e74c034adc80538f292315d71737e0 new file mode 100644 index 0000000..ee6191e Binary files /dev/null and b/fuzz/corpus/alloc_ops/71788f8d79e74c034adc80538f292315d71737e0 differ diff --git a/fuzz/corpus/alloc_ops/719d8f0dd2fca344d68ae5ba701146a2a67ab358 b/fuzz/corpus/alloc_ops/719d8f0dd2fca344d68ae5ba701146a2a67ab358 new file mode 100644 index 0000000..3676248 Binary files /dev/null and b/fuzz/corpus/alloc_ops/719d8f0dd2fca344d68ae5ba701146a2a67ab358 differ diff --git a/fuzz/corpus/alloc_ops/71bad1d047fd28ae0588b1c925f372068f9fa8fa b/fuzz/corpus/alloc_ops/71bad1d047fd28ae0588b1c925f372068f9fa8fa new file mode 100644 index 0000000..22e7cb0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/71bad1d047fd28ae0588b1c925f372068f9fa8fa differ diff --git a/fuzz/corpus/alloc_ops/71d9a43aac15afae927cf4a2ef7a3ffb63fecf9f b/fuzz/corpus/alloc_ops/71d9a43aac15afae927cf4a2ef7a3ffb63fecf9f new file mode 100644 index 0000000..92b1b3a Binary files /dev/null and b/fuzz/corpus/alloc_ops/71d9a43aac15afae927cf4a2ef7a3ffb63fecf9f differ diff --git a/fuzz/corpus/alloc_ops/721060584b9bab31c7e7439340ea57c045cf29f3 b/fuzz/corpus/alloc_ops/721060584b9bab31c7e7439340ea57c045cf29f3 new file mode 100644 index 0000000..546f7e0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/721060584b9bab31c7e7439340ea57c045cf29f3 differ diff --git a/fuzz/corpus/alloc_ops/72316b9601df02f4860dbd82498641338de4d848 b/fuzz/corpus/alloc_ops/72316b9601df02f4860dbd82498641338de4d848 new file mode 100644 index 0000000..9ec4af7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/72316b9601df02f4860dbd82498641338de4d848 differ diff --git a/fuzz/corpus/alloc_ops/72405345328c0513b2c84458326fe59dfc45d7e0 b/fuzz/corpus/alloc_ops/72405345328c0513b2c84458326fe59dfc45d7e0 new file mode 100644 index 0000000..643885b Binary files /dev/null and b/fuzz/corpus/alloc_ops/72405345328c0513b2c84458326fe59dfc45d7e0 differ diff --git a/fuzz/corpus/alloc_ops/726a953c3cd8a80841440a1938d9fe26c890cfbc b/fuzz/corpus/alloc_ops/726a953c3cd8a80841440a1938d9fe26c890cfbc new file mode 100644 index 0000000..2b89939 Binary files /dev/null and b/fuzz/corpus/alloc_ops/726a953c3cd8a80841440a1938d9fe26c890cfbc differ diff --git a/fuzz/corpus/alloc_ops/72848eb1ed03f33c57b0bcd080bcca3f6537229b b/fuzz/corpus/alloc_ops/72848eb1ed03f33c57b0bcd080bcca3f6537229b new file mode 100644 index 0000000..98568d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/72848eb1ed03f33c57b0bcd080bcca3f6537229b differ diff --git a/fuzz/corpus/alloc_ops/728ba7f077a4c2713d5ea532a10b209e3916cc0b b/fuzz/corpus/alloc_ops/728ba7f077a4c2713d5ea532a10b209e3916cc0b new file mode 100644 index 0000000..f345a43 Binary files /dev/null and b/fuzz/corpus/alloc_ops/728ba7f077a4c2713d5ea532a10b209e3916cc0b differ diff --git a/fuzz/corpus/alloc_ops/72a1e2c1a7ae422cf1c28bdd50cda5e5f7243a1c b/fuzz/corpus/alloc_ops/72a1e2c1a7ae422cf1c28bdd50cda5e5f7243a1c new file mode 100644 index 0000000..7f44093 Binary files /dev/null and b/fuzz/corpus/alloc_ops/72a1e2c1a7ae422cf1c28bdd50cda5e5f7243a1c differ diff --git a/fuzz/corpus/alloc_ops/730a7963fdcdb150bde50be248831d96c99c04b9 b/fuzz/corpus/alloc_ops/730a7963fdcdb150bde50be248831d96c99c04b9 new file mode 100644 index 0000000..fe6bf84 Binary files /dev/null and b/fuzz/corpus/alloc_ops/730a7963fdcdb150bde50be248831d96c99c04b9 differ diff --git a/fuzz/corpus/alloc_ops/732b2318c0d6b6dd35195229e7362a42a8f90e35 b/fuzz/corpus/alloc_ops/732b2318c0d6b6dd35195229e7362a42a8f90e35 new file mode 100644 index 0000000..972b698 Binary files /dev/null and b/fuzz/corpus/alloc_ops/732b2318c0d6b6dd35195229e7362a42a8f90e35 differ diff --git a/fuzz/corpus/alloc_ops/732b6f06fd83a0ffc7777485025ca45551040411 b/fuzz/corpus/alloc_ops/732b6f06fd83a0ffc7777485025ca45551040411 new file mode 100644 index 0000000..2c58224 Binary files /dev/null and b/fuzz/corpus/alloc_ops/732b6f06fd83a0ffc7777485025ca45551040411 differ diff --git a/fuzz/corpus/alloc_ops/735f96f7f45ce3367677d68fd85bbe19b411dfc5 b/fuzz/corpus/alloc_ops/735f96f7f45ce3367677d68fd85bbe19b411dfc5 new file mode 100644 index 0000000..58038f2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/735f96f7f45ce3367677d68fd85bbe19b411dfc5 differ diff --git a/fuzz/corpus/alloc_ops/736c649c3bfcc830fbfa31000d2171194f424aab b/fuzz/corpus/alloc_ops/736c649c3bfcc830fbfa31000d2171194f424aab new file mode 100644 index 0000000..9fe27b3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/736c649c3bfcc830fbfa31000d2171194f424aab differ diff --git a/fuzz/corpus/alloc_ops/7378d014cafdaa81e7e56ee18d58f59464baf5c1 b/fuzz/corpus/alloc_ops/7378d014cafdaa81e7e56ee18d58f59464baf5c1 new file mode 100644 index 0000000..72020e0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7378d014cafdaa81e7e56ee18d58f59464baf5c1 differ diff --git a/fuzz/corpus/alloc_ops/7385e0168e8c3152d78733194678e46e9da59636 b/fuzz/corpus/alloc_ops/7385e0168e8c3152d78733194678e46e9da59636 new file mode 100644 index 0000000..ca92d0e Binary files /dev/null and b/fuzz/corpus/alloc_ops/7385e0168e8c3152d78733194678e46e9da59636 differ diff --git a/fuzz/corpus/alloc_ops/738bcdf16e6b7f3d21a7eaeb3a010724a7acef0c b/fuzz/corpus/alloc_ops/738bcdf16e6b7f3d21a7eaeb3a010724a7acef0c new file mode 100644 index 0000000..259cf45 Binary files /dev/null and b/fuzz/corpus/alloc_ops/738bcdf16e6b7f3d21a7eaeb3a010724a7acef0c differ diff --git a/fuzz/corpus/alloc_ops/73cb8be7bd1b78bf4175acad28f74452e4b363e9 b/fuzz/corpus/alloc_ops/73cb8be7bd1b78bf4175acad28f74452e4b363e9 new file mode 100644 index 0000000..68eb877 --- /dev/null +++ b/fuzz/corpus/alloc_ops/73cb8be7bd1b78bf4175acad28f74452e4b363e9 @@ -0,0 +1,3 @@ +öööööööööö +öööööööööööööööö +ö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/73e89d50906780983ca43feefa2f39d8e6b66553 b/fuzz/corpus/alloc_ops/73e89d50906780983ca43feefa2f39d8e6b66553 new file mode 100644 index 0000000..d59fd2a Binary files /dev/null and b/fuzz/corpus/alloc_ops/73e89d50906780983ca43feefa2f39d8e6b66553 differ diff --git a/fuzz/corpus/alloc_ops/745049045acc99ff03917ab32fad2bebafd7a0e1 b/fuzz/corpus/alloc_ops/745049045acc99ff03917ab32fad2bebafd7a0e1 new file mode 100644 index 0000000..fdbc3dd Binary files /dev/null and b/fuzz/corpus/alloc_ops/745049045acc99ff03917ab32fad2bebafd7a0e1 differ diff --git a/fuzz/corpus/alloc_ops/745e52a699bc363010b4528947d6abe6fc822a3e b/fuzz/corpus/alloc_ops/745e52a699bc363010b4528947d6abe6fc822a3e new file mode 100644 index 0000000..fdd8aa1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/745e52a699bc363010b4528947d6abe6fc822a3e differ diff --git a/fuzz/corpus/alloc_ops/7486453ae29d5f406f6c9568ba3e75f789eb5224 b/fuzz/corpus/alloc_ops/7486453ae29d5f406f6c9568ba3e75f789eb5224 new file mode 100644 index 0000000..eb000de Binary files /dev/null and b/fuzz/corpus/alloc_ops/7486453ae29d5f406f6c9568ba3e75f789eb5224 differ diff --git a/fuzz/corpus/alloc_ops/74c59c4ae6d39bff9313e04e9cd6e9b42a5226f3 b/fuzz/corpus/alloc_ops/74c59c4ae6d39bff9313e04e9cd6e9b42a5226f3 new file mode 100644 index 0000000..e8bcbe3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/74c59c4ae6d39bff9313e04e9cd6e9b42a5226f3 differ diff --git a/fuzz/corpus/alloc_ops/74f0d859f69da8a5f748e3fc3bac3cc0c81f2dac b/fuzz/corpus/alloc_ops/74f0d859f69da8a5f748e3fc3bac3cc0c81f2dac new file mode 100644 index 0000000..29d0c88 Binary files /dev/null and b/fuzz/corpus/alloc_ops/74f0d859f69da8a5f748e3fc3bac3cc0c81f2dac differ diff --git a/fuzz/corpus/alloc_ops/753293183ce3c19b1ca20601328ffaa0c9ead8e7 b/fuzz/corpus/alloc_ops/753293183ce3c19b1ca20601328ffaa0c9ead8e7 new file mode 100644 index 0000000..f89c645 Binary files /dev/null and b/fuzz/corpus/alloc_ops/753293183ce3c19b1ca20601328ffaa0c9ead8e7 differ diff --git a/fuzz/corpus/alloc_ops/754390d64d273fed17cffbb2ca6a059f1f790df9 b/fuzz/corpus/alloc_ops/754390d64d273fed17cffbb2ca6a059f1f790df9 new file mode 100644 index 0000000..4c3eefe Binary files /dev/null and b/fuzz/corpus/alloc_ops/754390d64d273fed17cffbb2ca6a059f1f790df9 differ diff --git a/fuzz/corpus/alloc_ops/7570b659a30ec75774ea1a50714afba7e5c21048 b/fuzz/corpus/alloc_ops/7570b659a30ec75774ea1a50714afba7e5c21048 new file mode 100644 index 0000000..6efc311 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7570b659a30ec75774ea1a50714afba7e5c21048 differ diff --git a/fuzz/corpus/alloc_ops/7576816ca2d3525dfd91df8f8bd73eef914f75d8 b/fuzz/corpus/alloc_ops/7576816ca2d3525dfd91df8f8bd73eef914f75d8 new file mode 100644 index 0000000..308f1f0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7576816ca2d3525dfd91df8f8bd73eef914f75d8 differ diff --git a/fuzz/corpus/alloc_ops/75a3c52c7727be0e8a2364f6d3443f7196b08bbd b/fuzz/corpus/alloc_ops/75a3c52c7727be0e8a2364f6d3443f7196b08bbd new file mode 100644 index 0000000..c639bbb Binary files /dev/null and b/fuzz/corpus/alloc_ops/75a3c52c7727be0e8a2364f6d3443f7196b08bbd differ diff --git a/fuzz/corpus/alloc_ops/75a6c73a83a774e179915b21aa25e391ed9ccb7c b/fuzz/corpus/alloc_ops/75a6c73a83a774e179915b21aa25e391ed9ccb7c new file mode 100644 index 0000000..517db7b Binary files /dev/null and b/fuzz/corpus/alloc_ops/75a6c73a83a774e179915b21aa25e391ed9ccb7c differ diff --git a/fuzz/corpus/alloc_ops/75a8dca5f41d35937dfd27ae04a0e28458d48a28 b/fuzz/corpus/alloc_ops/75a8dca5f41d35937dfd27ae04a0e28458d48a28 new file mode 100644 index 0000000..46ea01c Binary files /dev/null and b/fuzz/corpus/alloc_ops/75a8dca5f41d35937dfd27ae04a0e28458d48a28 differ diff --git a/fuzz/corpus/alloc_ops/75bbc30e0294037fe91dc6541d3754c6ab77723d b/fuzz/corpus/alloc_ops/75bbc30e0294037fe91dc6541d3754c6ab77723d new file mode 100644 index 0000000..bacd9a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/75bbc30e0294037fe91dc6541d3754c6ab77723d differ diff --git a/fuzz/corpus/alloc_ops/7626ab446513424646f7075df8fc2d8106a4fbc6 b/fuzz/corpus/alloc_ops/7626ab446513424646f7075df8fc2d8106a4fbc6 new file mode 100644 index 0000000..1bc38cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/7626ab446513424646f7075df8fc2d8106a4fbc6 differ diff --git a/fuzz/corpus/alloc_ops/763a0acda624db4e0789e301836f35977f7aba8d b/fuzz/corpus/alloc_ops/763a0acda624db4e0789e301836f35977f7aba8d new file mode 100644 index 0000000..f49f960 Binary files /dev/null and b/fuzz/corpus/alloc_ops/763a0acda624db4e0789e301836f35977f7aba8d differ diff --git a/fuzz/corpus/alloc_ops/76c8c51d754b18bbf6e9223b8080ebbcd5b04cca b/fuzz/corpus/alloc_ops/76c8c51d754b18bbf6e9223b8080ebbcd5b04cca new file mode 100644 index 0000000..d505873 Binary files /dev/null and b/fuzz/corpus/alloc_ops/76c8c51d754b18bbf6e9223b8080ebbcd5b04cca differ diff --git a/fuzz/corpus/alloc_ops/772a6d376c982afa8d9d8bbe6e90dc6ae72d0775 b/fuzz/corpus/alloc_ops/772a6d376c982afa8d9d8bbe6e90dc6ae72d0775 new file mode 100644 index 0000000..18fa0b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/772a6d376c982afa8d9d8bbe6e90dc6ae72d0775 differ diff --git a/fuzz/corpus/alloc_ops/775abcdb4ba30b41558491c42524f98a78e31a4d b/fuzz/corpus/alloc_ops/775abcdb4ba30b41558491c42524f98a78e31a4d new file mode 100644 index 0000000..f2adabc Binary files /dev/null and b/fuzz/corpus/alloc_ops/775abcdb4ba30b41558491c42524f98a78e31a4d differ diff --git a/fuzz/corpus/alloc_ops/77a55e8dd56f4428497116b91d4c0c3ba932425c b/fuzz/corpus/alloc_ops/77a55e8dd56f4428497116b91d4c0c3ba932425c new file mode 100644 index 0000000..1987bbd --- /dev/null +++ b/fuzz/corpus/alloc_ops/77a55e8dd56f4428497116b91d4c0c3ba932425c @@ -0,0 +1 @@ +µ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/77e6079d836e37cf8ba50aa23a281b7021d39704 b/fuzz/corpus/alloc_ops/77e6079d836e37cf8ba50aa23a281b7021d39704 new file mode 100644 index 0000000..46c748f Binary files /dev/null and b/fuzz/corpus/alloc_ops/77e6079d836e37cf8ba50aa23a281b7021d39704 differ diff --git a/fuzz/corpus/alloc_ops/78174b152cae786aac59ed70cb3732c33c84c07d b/fuzz/corpus/alloc_ops/78174b152cae786aac59ed70cb3732c33c84c07d new file mode 100644 index 0000000..8b402a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/78174b152cae786aac59ed70cb3732c33c84c07d differ diff --git a/fuzz/corpus/alloc_ops/785790d7837d35c1cad36a75ee71ed526f0d3345 b/fuzz/corpus/alloc_ops/785790d7837d35c1cad36a75ee71ed526f0d3345 new file mode 100644 index 0000000..d7919f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/785790d7837d35c1cad36a75ee71ed526f0d3345 differ diff --git a/fuzz/corpus/alloc_ops/78bdebdfc93d08887060781167626b0e9be4f991 b/fuzz/corpus/alloc_ops/78bdebdfc93d08887060781167626b0e9be4f991 new file mode 100644 index 0000000..204173c --- /dev/null +++ b/fuzz/corpus/alloc_ops/78bdebdfc93d08887060781167626b0e9be4f991 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/790399fad1f86beb8923c2fbd4e40b33dcd0c4d8 b/fuzz/corpus/alloc_ops/790399fad1f86beb8923c2fbd4e40b33dcd0c4d8 new file mode 100644 index 0000000..d237437 Binary files /dev/null and b/fuzz/corpus/alloc_ops/790399fad1f86beb8923c2fbd4e40b33dcd0c4d8 differ diff --git a/fuzz/corpus/alloc_ops/7922c815deedd49de0d8c5e1b3f0f8d49279f8ba b/fuzz/corpus/alloc_ops/7922c815deedd49de0d8c5e1b3f0f8d49279f8ba new file mode 100644 index 0000000..310c840 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7922c815deedd49de0d8c5e1b3f0f8d49279f8ba differ diff --git a/fuzz/corpus/alloc_ops/79354d37dc4f2316b57a624dbff0d696f3b1b81b b/fuzz/corpus/alloc_ops/79354d37dc4f2316b57a624dbff0d696f3b1b81b new file mode 100644 index 0000000..915dd8a --- /dev/null +++ b/fuzz/corpus/alloc_ops/79354d37dc4f2316b57a624dbff0d696f3b1b81b @@ -0,0 +1,2 @@ +¥è +èèèèèèèèèèèèèèèèèèèööööÿÿÿ$)))))))))) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/794ea97c82fb914b081e009e39752070635d552f b/fuzz/corpus/alloc_ops/794ea97c82fb914b081e009e39752070635d552f new file mode 100644 index 0000000..6acfc2d Binary files /dev/null and b/fuzz/corpus/alloc_ops/794ea97c82fb914b081e009e39752070635d552f differ diff --git a/fuzz/corpus/alloc_ops/799aa09edfd8e6999d246382b6fe2725c412d3b3 b/fuzz/corpus/alloc_ops/799aa09edfd8e6999d246382b6fe2725c412d3b3 new file mode 100644 index 0000000..881cd61 Binary files /dev/null and b/fuzz/corpus/alloc_ops/799aa09edfd8e6999d246382b6fe2725c412d3b3 differ diff --git a/fuzz/corpus/alloc_ops/79c4a7a38131f3e4be169147159ad65f957448b0 b/fuzz/corpus/alloc_ops/79c4a7a38131f3e4be169147159ad65f957448b0 new file mode 100644 index 0000000..4e83c4f Binary files /dev/null and b/fuzz/corpus/alloc_ops/79c4a7a38131f3e4be169147159ad65f957448b0 differ diff --git a/fuzz/corpus/alloc_ops/79dbcb2028425d41187496cd03e86ac64c9f1e35 b/fuzz/corpus/alloc_ops/79dbcb2028425d41187496cd03e86ac64c9f1e35 new file mode 100644 index 0000000..09519b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/79dbcb2028425d41187496cd03e86ac64c9f1e35 differ diff --git a/fuzz/corpus/alloc_ops/7a10cba468acb0b1c2b5e11155cfc1fb767e203d b/fuzz/corpus/alloc_ops/7a10cba468acb0b1c2b5e11155cfc1fb767e203d new file mode 100644 index 0000000..4b1e97c Binary files /dev/null and b/fuzz/corpus/alloc_ops/7a10cba468acb0b1c2b5e11155cfc1fb767e203d differ diff --git a/fuzz/corpus/alloc_ops/7aa0c82af0b4584af348d674acb4e2e47e3d4f2d b/fuzz/corpus/alloc_ops/7aa0c82af0b4584af348d674acb4e2e47e3d4f2d new file mode 100644 index 0000000..43a7a7c Binary files /dev/null and b/fuzz/corpus/alloc_ops/7aa0c82af0b4584af348d674acb4e2e47e3d4f2d differ diff --git a/fuzz/corpus/alloc_ops/7abb0df1ded715e20e70a423b76bfe0e84d5a425 b/fuzz/corpus/alloc_ops/7abb0df1ded715e20e70a423b76bfe0e84d5a425 new file mode 100644 index 0000000..c4f49d5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7abb0df1ded715e20e70a423b76bfe0e84d5a425 differ diff --git a/fuzz/corpus/alloc_ops/7ac545bbdef73ca68357050252dbd02056103b1d b/fuzz/corpus/alloc_ops/7ac545bbdef73ca68357050252dbd02056103b1d new file mode 100644 index 0000000..35e9be8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7ac545bbdef73ca68357050252dbd02056103b1d differ diff --git a/fuzz/corpus/alloc_ops/7ad42b3420a32aad9dac0c6717c81944a690aa38 b/fuzz/corpus/alloc_ops/7ad42b3420a32aad9dac0c6717c81944a690aa38 new file mode 100644 index 0000000..7910168 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7ad42b3420a32aad9dac0c6717c81944a690aa38 differ diff --git a/fuzz/corpus/alloc_ops/7b4ff11280ae48512e157bd4f4d3977bf7e72f3c b/fuzz/corpus/alloc_ops/7b4ff11280ae48512e157bd4f4d3977bf7e72f3c new file mode 100644 index 0000000..040cd75 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7b4ff11280ae48512e157bd4f4d3977bf7e72f3c differ diff --git a/fuzz/corpus/alloc_ops/7b51720c442cc5f76b010c5d35a142d71053108f b/fuzz/corpus/alloc_ops/7b51720c442cc5f76b010c5d35a142d71053108f new file mode 100644 index 0000000..d8d5334 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7b51720c442cc5f76b010c5d35a142d71053108f differ diff --git a/fuzz/corpus/alloc_ops/7b615d46e7fc420218307001f93c22d7da34216b b/fuzz/corpus/alloc_ops/7b615d46e7fc420218307001f93c22d7da34216b new file mode 100644 index 0000000..6277b05 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7b615d46e7fc420218307001f93c22d7da34216b differ diff --git a/fuzz/corpus/alloc_ops/7ba0db08e2187e0215bce77123b028c81fc817cd b/fuzz/corpus/alloc_ops/7ba0db08e2187e0215bce77123b028c81fc817cd new file mode 100644 index 0000000..30da844 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7ba0db08e2187e0215bce77123b028c81fc817cd differ diff --git a/fuzz/corpus/alloc_ops/7ba1494ce738230c0eafbdee5b7f0a05c495b5c5 b/fuzz/corpus/alloc_ops/7ba1494ce738230c0eafbdee5b7f0a05c495b5c5 new file mode 100644 index 0000000..984744e Binary files /dev/null and b/fuzz/corpus/alloc_ops/7ba1494ce738230c0eafbdee5b7f0a05c495b5c5 differ diff --git a/fuzz/corpus/alloc_ops/7bfe2521f5af5aff9d2b1f684a6f382133738e68 b/fuzz/corpus/alloc_ops/7bfe2521f5af5aff9d2b1f684a6f382133738e68 new file mode 100644 index 0000000..cc9b326 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7bfe2521f5af5aff9d2b1f684a6f382133738e68 differ diff --git a/fuzz/corpus/alloc_ops/7c21b715dd3c5c3b59b5cc16f1f32743d75d22ae b/fuzz/corpus/alloc_ops/7c21b715dd3c5c3b59b5cc16f1f32743d75d22ae new file mode 100644 index 0000000..3d40400 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7c21b715dd3c5c3b59b5cc16f1f32743d75d22ae differ diff --git a/fuzz/corpus/alloc_ops/7c544cf41fae9336af78964a230c36168b728ec7 b/fuzz/corpus/alloc_ops/7c544cf41fae9336af78964a230c36168b728ec7 new file mode 100644 index 0000000..3cef115 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7c544cf41fae9336af78964a230c36168b728ec7 differ diff --git a/fuzz/corpus/alloc_ops/7c87f55387b8b97c2f8e2b93af5cae07821b10a6 b/fuzz/corpus/alloc_ops/7c87f55387b8b97c2f8e2b93af5cae07821b10a6 new file mode 100644 index 0000000..984b09b Binary files /dev/null and b/fuzz/corpus/alloc_ops/7c87f55387b8b97c2f8e2b93af5cae07821b10a6 differ diff --git a/fuzz/corpus/alloc_ops/7cf12c216cada64e598787a4a2dc6df684478344 b/fuzz/corpus/alloc_ops/7cf12c216cada64e598787a4a2dc6df684478344 new file mode 100644 index 0000000..e4ecd58 --- /dev/null +++ b/fuzz/corpus/alloc_ops/7cf12c216cada64e598787a4a2dc6df684478344 @@ -0,0 +1 @@ +0ooooo)ÿoioooooooooooooooooooooQ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/7d6a720ed7874ffeb7e57c6aa0f09ea411506813 b/fuzz/corpus/alloc_ops/7d6a720ed7874ffeb7e57c6aa0f09ea411506813 new file mode 100644 index 0000000..dbb9df9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7d6a720ed7874ffeb7e57c6aa0f09ea411506813 differ diff --git a/fuzz/corpus/alloc_ops/7dc5f59b56dc66dabfce3662558ef2f8b3a8e31b b/fuzz/corpus/alloc_ops/7dc5f59b56dc66dabfce3662558ef2f8b3a8e31b new file mode 100644 index 0000000..ae96673 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7dc5f59b56dc66dabfce3662558ef2f8b3a8e31b differ diff --git a/fuzz/corpus/alloc_ops/7dcabda0e7c45e00a9ab9a9725b45955b8c74b6f b/fuzz/corpus/alloc_ops/7dcabda0e7c45e00a9ab9a9725b45955b8c74b6f new file mode 100644 index 0000000..44c003c Binary files /dev/null and b/fuzz/corpus/alloc_ops/7dcabda0e7c45e00a9ab9a9725b45955b8c74b6f differ diff --git a/fuzz/corpus/alloc_ops/7e1d189c1ad02286086da34af15655204b07b931 b/fuzz/corpus/alloc_ops/7e1d189c1ad02286086da34af15655204b07b931 new file mode 100644 index 0000000..3b799ba Binary files /dev/null and b/fuzz/corpus/alloc_ops/7e1d189c1ad02286086da34af15655204b07b931 differ diff --git a/fuzz/corpus/alloc_ops/7e498bd8450e197f9016fc3476e71e96e0c67034 b/fuzz/corpus/alloc_ops/7e498bd8450e197f9016fc3476e71e96e0c67034 new file mode 100644 index 0000000..d2e136d --- /dev/null +++ b/fuzz/corpus/alloc_ops/7e498bd8450e197f9016fc3476e71e96e0c67034 @@ -0,0 +1 @@ +þµþþþþþþþþþþþþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/7e98ef3f8d2687f1a46d236d82a874e5e9df62a4 b/fuzz/corpus/alloc_ops/7e98ef3f8d2687f1a46d236d82a874e5e9df62a4 new file mode 100644 index 0000000..c173bb3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7e98ef3f8d2687f1a46d236d82a874e5e9df62a4 differ diff --git a/fuzz/corpus/alloc_ops/7efd7dff75b0240dd14d244e6acbcebf2fb6eefd b/fuzz/corpus/alloc_ops/7efd7dff75b0240dd14d244e6acbcebf2fb6eefd new file mode 100644 index 0000000..0df207f Binary files /dev/null and b/fuzz/corpus/alloc_ops/7efd7dff75b0240dd14d244e6acbcebf2fb6eefd differ diff --git a/fuzz/corpus/alloc_ops/7f00364de26d9ac37cc9a2b1a008f92e718d3c45 b/fuzz/corpus/alloc_ops/7f00364de26d9ac37cc9a2b1a008f92e718d3c45 new file mode 100644 index 0000000..18fd47e Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f00364de26d9ac37cc9a2b1a008f92e718d3c45 differ diff --git a/fuzz/corpus/alloc_ops/7f208667f4d45f054638abadd2221f15ea4d4ff1 b/fuzz/corpus/alloc_ops/7f208667f4d45f054638abadd2221f15ea4d4ff1 new file mode 100644 index 0000000..28dbec2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f208667f4d45f054638abadd2221f15ea4d4ff1 differ diff --git a/fuzz/corpus/alloc_ops/7f3db0f4e5d227356145f0b5851db106c22da1c0 b/fuzz/corpus/alloc_ops/7f3db0f4e5d227356145f0b5851db106c22da1c0 new file mode 100644 index 0000000..8efaa21 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f3db0f4e5d227356145f0b5851db106c22da1c0 differ diff --git a/fuzz/corpus/alloc_ops/7f4990e7aabdfb753e69304d3b679caa2d751c49 b/fuzz/corpus/alloc_ops/7f4990e7aabdfb753e69304d3b679caa2d751c49 new file mode 100644 index 0000000..2ef6369 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f4990e7aabdfb753e69304d3b679caa2d751c49 differ diff --git a/fuzz/corpus/alloc_ops/7f5e9b617f336f959af8d92c40ceae294d8875eb b/fuzz/corpus/alloc_ops/7f5e9b617f336f959af8d92c40ceae294d8875eb new file mode 100644 index 0000000..7102e19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f5e9b617f336f959af8d92c40ceae294d8875eb differ diff --git a/fuzz/corpus/alloc_ops/7f6400a3e54d9b24d4380942c9fb0e72273d547b b/fuzz/corpus/alloc_ops/7f6400a3e54d9b24d4380942c9fb0e72273d547b new file mode 100644 index 0000000..695c92d Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f6400a3e54d9b24d4380942c9fb0e72273d547b differ diff --git a/fuzz/corpus/alloc_ops/7f805a0dfbdc8fc9b4a473c88cb174e2eb80ec25 b/fuzz/corpus/alloc_ops/7f805a0dfbdc8fc9b4a473c88cb174e2eb80ec25 new file mode 100644 index 0000000..cac75b0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7f805a0dfbdc8fc9b4a473c88cb174e2eb80ec25 differ diff --git a/fuzz/corpus/alloc_ops/7fa58c4ce06fc729a3b03b381a370539e2bf6b43 b/fuzz/corpus/alloc_ops/7fa58c4ce06fc729a3b03b381a370539e2bf6b43 new file mode 100644 index 0000000..02afb26 Binary files /dev/null and b/fuzz/corpus/alloc_ops/7fa58c4ce06fc729a3b03b381a370539e2bf6b43 differ diff --git a/fuzz/corpus/alloc_ops/800391156db34069c7287af638f8ccaaf2d59b01 b/fuzz/corpus/alloc_ops/800391156db34069c7287af638f8ccaaf2d59b01 new file mode 100644 index 0000000..11c4f38 Binary files /dev/null and b/fuzz/corpus/alloc_ops/800391156db34069c7287af638f8ccaaf2d59b01 differ diff --git a/fuzz/corpus/alloc_ops/8019da2ab353620b218237bfeb2d323512feb278 b/fuzz/corpus/alloc_ops/8019da2ab353620b218237bfeb2d323512feb278 new file mode 100644 index 0000000..1dbaa5b Binary files /dev/null and b/fuzz/corpus/alloc_ops/8019da2ab353620b218237bfeb2d323512feb278 differ diff --git a/fuzz/corpus/alloc_ops/803913ee311c9cbbb554344a263d17ffefd4f083 b/fuzz/corpus/alloc_ops/803913ee311c9cbbb554344a263d17ffefd4f083 new file mode 100644 index 0000000..cf36f96 Binary files /dev/null and b/fuzz/corpus/alloc_ops/803913ee311c9cbbb554344a263d17ffefd4f083 differ diff --git a/fuzz/corpus/alloc_ops/8061f3e9384f2f0cd7cfbca0d6cca4d4c969b736 b/fuzz/corpus/alloc_ops/8061f3e9384f2f0cd7cfbca0d6cca4d4c969b736 new file mode 100644 index 0000000..4bcd1ee Binary files /dev/null and b/fuzz/corpus/alloc_ops/8061f3e9384f2f0cd7cfbca0d6cca4d4c969b736 differ diff --git a/fuzz/corpus/alloc_ops/8085919cbaaa1cf3bde72441866513830d1af889 b/fuzz/corpus/alloc_ops/8085919cbaaa1cf3bde72441866513830d1af889 new file mode 100644 index 0000000..bfc329e Binary files /dev/null and b/fuzz/corpus/alloc_ops/8085919cbaaa1cf3bde72441866513830d1af889 differ diff --git a/fuzz/corpus/alloc_ops/809cc02da57ece67e3618260875632fd62005b33 b/fuzz/corpus/alloc_ops/809cc02da57ece67e3618260875632fd62005b33 new file mode 100644 index 0000000..bf92fb6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/809cc02da57ece67e3618260875632fd62005b33 differ diff --git a/fuzz/corpus/alloc_ops/80ad057aa83fdf310012d0419c2d9becf0e04d6d b/fuzz/corpus/alloc_ops/80ad057aa83fdf310012d0419c2d9becf0e04d6d new file mode 100644 index 0000000..95758f2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/80ad057aa83fdf310012d0419c2d9becf0e04d6d differ diff --git a/fuzz/corpus/alloc_ops/80b85e0784a41a43d8349189c68b5abeb7a31718 b/fuzz/corpus/alloc_ops/80b85e0784a41a43d8349189c68b5abeb7a31718 new file mode 100644 index 0000000..277b035 Binary files /dev/null and b/fuzz/corpus/alloc_ops/80b85e0784a41a43d8349189c68b5abeb7a31718 differ diff --git a/fuzz/corpus/alloc_ops/80d250e0297333148e41971c095409348aa6c502 b/fuzz/corpus/alloc_ops/80d250e0297333148e41971c095409348aa6c502 new file mode 100644 index 0000000..ade437c Binary files /dev/null and b/fuzz/corpus/alloc_ops/80d250e0297333148e41971c095409348aa6c502 differ diff --git a/fuzz/corpus/alloc_ops/8139dffd5eb66d332db1f3b663c133e2cbf1222e b/fuzz/corpus/alloc_ops/8139dffd5eb66d332db1f3b663c133e2cbf1222e new file mode 100644 index 0000000..0be8fb3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8139dffd5eb66d332db1f3b663c133e2cbf1222e differ diff --git a/fuzz/corpus/alloc_ops/813b9d2e4b0d4a57482d0ce595337d024aa23481 b/fuzz/corpus/alloc_ops/813b9d2e4b0d4a57482d0ce595337d024aa23481 new file mode 100644 index 0000000..85d00f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/813b9d2e4b0d4a57482d0ce595337d024aa23481 differ diff --git a/fuzz/corpus/alloc_ops/815df7f464baaefa6e000aab4edbfc82f74d98d2 b/fuzz/corpus/alloc_ops/815df7f464baaefa6e000aab4edbfc82f74d98d2 new file mode 100644 index 0000000..bbb70dc Binary files /dev/null and b/fuzz/corpus/alloc_ops/815df7f464baaefa6e000aab4edbfc82f74d98d2 differ diff --git a/fuzz/corpus/alloc_ops/8160e56cf23a0f1260d286e2f27d0bf9d5520bbc b/fuzz/corpus/alloc_ops/8160e56cf23a0f1260d286e2f27d0bf9d5520bbc new file mode 100644 index 0000000..26fe2b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8160e56cf23a0f1260d286e2f27d0bf9d5520bbc differ diff --git a/fuzz/corpus/alloc_ops/81d8138dfe34f7d5a3c9186bef09ea4205037426 b/fuzz/corpus/alloc_ops/81d8138dfe34f7d5a3c9186bef09ea4205037426 new file mode 100644 index 0000000..5aa6a3e Binary files /dev/null and b/fuzz/corpus/alloc_ops/81d8138dfe34f7d5a3c9186bef09ea4205037426 differ diff --git a/fuzz/corpus/alloc_ops/81e045d925e61527825f7c33ce3f54675bbc3eca b/fuzz/corpus/alloc_ops/81e045d925e61527825f7c33ce3f54675bbc3eca new file mode 100644 index 0000000..608184c Binary files /dev/null and b/fuzz/corpus/alloc_ops/81e045d925e61527825f7c33ce3f54675bbc3eca differ diff --git a/fuzz/corpus/alloc_ops/8204a66fb11da7ee17ba66b9e3bbba65dc1ced44 b/fuzz/corpus/alloc_ops/8204a66fb11da7ee17ba66b9e3bbba65dc1ced44 new file mode 100644 index 0000000..fc253ea Binary files /dev/null and b/fuzz/corpus/alloc_ops/8204a66fb11da7ee17ba66b9e3bbba65dc1ced44 differ diff --git a/fuzz/corpus/alloc_ops/825ac155fc787d00341c9f8688da146e5830fd94 b/fuzz/corpus/alloc_ops/825ac155fc787d00341c9f8688da146e5830fd94 new file mode 100644 index 0000000..dc4ccb8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/825ac155fc787d00341c9f8688da146e5830fd94 differ diff --git a/fuzz/corpus/alloc_ops/82717df3197080b77590d91147f48f907d4b086b b/fuzz/corpus/alloc_ops/82717df3197080b77590d91147f48f907d4b086b new file mode 100644 index 0000000..ea70750 Binary files /dev/null and b/fuzz/corpus/alloc_ops/82717df3197080b77590d91147f48f907d4b086b differ diff --git a/fuzz/corpus/alloc_ops/8286865c03634310540c162eec95b125d5f63e84 b/fuzz/corpus/alloc_ops/8286865c03634310540c162eec95b125d5f63e84 new file mode 100644 index 0000000..f3578e3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8286865c03634310540c162eec95b125d5f63e84 differ diff --git a/fuzz/corpus/alloc_ops/82a33a02f8bdde1b15b96fdc3f6686976a7e8e90 b/fuzz/corpus/alloc_ops/82a33a02f8bdde1b15b96fdc3f6686976a7e8e90 new file mode 100644 index 0000000..95cad35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/82a33a02f8bdde1b15b96fdc3f6686976a7e8e90 differ diff --git a/fuzz/corpus/alloc_ops/82bc478532a5c03bb6e16b98e905abe67c49cc63 b/fuzz/corpus/alloc_ops/82bc478532a5c03bb6e16b98e905abe67c49cc63 new file mode 100644 index 0000000..0c8927f Binary files /dev/null and b/fuzz/corpus/alloc_ops/82bc478532a5c03bb6e16b98e905abe67c49cc63 differ diff --git a/fuzz/corpus/alloc_ops/82d1fce5af9fae06377fb6ce2a205a0de662ab6b b/fuzz/corpus/alloc_ops/82d1fce5af9fae06377fb6ce2a205a0de662ab6b new file mode 100644 index 0000000..fa9f441 Binary files /dev/null and b/fuzz/corpus/alloc_ops/82d1fce5af9fae06377fb6ce2a205a0de662ab6b differ diff --git a/fuzz/corpus/alloc_ops/8306d9fb37318304ee8a1b911474c3e296727ec9 b/fuzz/corpus/alloc_ops/8306d9fb37318304ee8a1b911474c3e296727ec9 new file mode 100644 index 0000000..c5cba11 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8306d9fb37318304ee8a1b911474c3e296727ec9 differ diff --git a/fuzz/corpus/alloc_ops/8325b0be2ae37a9dd62bb5eb6e4753c426f23488 b/fuzz/corpus/alloc_ops/8325b0be2ae37a9dd62bb5eb6e4753c426f23488 new file mode 100644 index 0000000..99caa47 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8325b0be2ae37a9dd62bb5eb6e4753c426f23488 differ diff --git a/fuzz/corpus/alloc_ops/833ccb79e982c1e71ff299c992630e8ba9e25389 b/fuzz/corpus/alloc_ops/833ccb79e982c1e71ff299c992630e8ba9e25389 new file mode 100644 index 0000000..ed6c0e5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/833ccb79e982c1e71ff299c992630e8ba9e25389 differ diff --git a/fuzz/corpus/alloc_ops/835699efc7bed013e6d04eccee14f0a37f379440 b/fuzz/corpus/alloc_ops/835699efc7bed013e6d04eccee14f0a37f379440 new file mode 100644 index 0000000..73e699f Binary files /dev/null and b/fuzz/corpus/alloc_ops/835699efc7bed013e6d04eccee14f0a37f379440 differ diff --git a/fuzz/corpus/alloc_ops/836afcabbd8516e8feb55685220221fa68f92546 b/fuzz/corpus/alloc_ops/836afcabbd8516e8feb55685220221fa68f92546 new file mode 100644 index 0000000..609dfe7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/836afcabbd8516e8feb55685220221fa68f92546 differ diff --git a/fuzz/corpus/alloc_ops/8390e6ff0ec6091582dd4f6e47bed379dcf054fb b/fuzz/corpus/alloc_ops/8390e6ff0ec6091582dd4f6e47bed379dcf054fb new file mode 100644 index 0000000..467b1f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8390e6ff0ec6091582dd4f6e47bed379dcf054fb differ diff --git a/fuzz/corpus/alloc_ops/8396c04f32b023d9416f293e4ae254b0f5eaf400 b/fuzz/corpus/alloc_ops/8396c04f32b023d9416f293e4ae254b0f5eaf400 new file mode 100644 index 0000000..ae5a4bc Binary files /dev/null and b/fuzz/corpus/alloc_ops/8396c04f32b023d9416f293e4ae254b0f5eaf400 differ diff --git a/fuzz/corpus/alloc_ops/83b9e1baac4d1c4c2de3472c7004eebd70c273bb b/fuzz/corpus/alloc_ops/83b9e1baac4d1c4c2de3472c7004eebd70c273bb new file mode 100644 index 0000000..d4afaf4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/83b9e1baac4d1c4c2de3472c7004eebd70c273bb differ diff --git a/fuzz/corpus/alloc_ops/83f71f97fb068d3216c226622b3d429992ea6c9f b/fuzz/corpus/alloc_ops/83f71f97fb068d3216c226622b3d429992ea6c9f new file mode 100644 index 0000000..db9adec Binary files /dev/null and b/fuzz/corpus/alloc_ops/83f71f97fb068d3216c226622b3d429992ea6c9f differ diff --git a/fuzz/corpus/alloc_ops/840754118aaeed5d62008816eb2a095e4ca44a7b b/fuzz/corpus/alloc_ops/840754118aaeed5d62008816eb2a095e4ca44a7b new file mode 100644 index 0000000..8608d66 Binary files /dev/null and b/fuzz/corpus/alloc_ops/840754118aaeed5d62008816eb2a095e4ca44a7b differ diff --git a/fuzz/corpus/alloc_ops/8429ff4d8f143896cfa337e192553632174165e4 b/fuzz/corpus/alloc_ops/8429ff4d8f143896cfa337e192553632174165e4 new file mode 100644 index 0000000..e63c502 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8429ff4d8f143896cfa337e192553632174165e4 differ diff --git a/fuzz/corpus/alloc_ops/84381c48da6ebaab99e7f11399a5224c2fe04257 b/fuzz/corpus/alloc_ops/84381c48da6ebaab99e7f11399a5224c2fe04257 new file mode 100644 index 0000000..98b8ce1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/84381c48da6ebaab99e7f11399a5224c2fe04257 differ diff --git a/fuzz/corpus/alloc_ops/847640bcb69c46d157d28c5b01204692f9263c09 b/fuzz/corpus/alloc_ops/847640bcb69c46d157d28c5b01204692f9263c09 new file mode 100644 index 0000000..b3c9201 Binary files /dev/null and b/fuzz/corpus/alloc_ops/847640bcb69c46d157d28c5b01204692f9263c09 differ diff --git a/fuzz/corpus/alloc_ops/848d59f551b1a678623e6c8911d40048a0af538f b/fuzz/corpus/alloc_ops/848d59f551b1a678623e6c8911d40048a0af538f new file mode 100644 index 0000000..1eba2a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/848d59f551b1a678623e6c8911d40048a0af538f differ diff --git a/fuzz/corpus/alloc_ops/84bc0aea6599e2309a5540d9e8bb8bfc88698a73 b/fuzz/corpus/alloc_ops/84bc0aea6599e2309a5540d9e8bb8bfc88698a73 new file mode 100644 index 0000000..69f89ac Binary files /dev/null and b/fuzz/corpus/alloc_ops/84bc0aea6599e2309a5540d9e8bb8bfc88698a73 differ diff --git a/fuzz/corpus/alloc_ops/84faadad9b3b26a3cbfaedbcb4a9b1b6908d84ff b/fuzz/corpus/alloc_ops/84faadad9b3b26a3cbfaedbcb4a9b1b6908d84ff new file mode 100644 index 0000000..34c2c7f Binary files /dev/null and b/fuzz/corpus/alloc_ops/84faadad9b3b26a3cbfaedbcb4a9b1b6908d84ff differ diff --git a/fuzz/corpus/alloc_ops/8519a067eebf8bb767ba78fd093f56638848d5cc b/fuzz/corpus/alloc_ops/8519a067eebf8bb767ba78fd093f56638848d5cc new file mode 100644 index 0000000..1024374 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8519a067eebf8bb767ba78fd093f56638848d5cc differ diff --git a/fuzz/corpus/alloc_ops/85344149604ed376b4a6202abded458024edeed8 b/fuzz/corpus/alloc_ops/85344149604ed376b4a6202abded458024edeed8 new file mode 100644 index 0000000..6f00347 Binary files /dev/null and b/fuzz/corpus/alloc_ops/85344149604ed376b4a6202abded458024edeed8 differ diff --git a/fuzz/corpus/alloc_ops/8539cbe302c3d9f38d50552c50061ec1702040d0 b/fuzz/corpus/alloc_ops/8539cbe302c3d9f38d50552c50061ec1702040d0 new file mode 100644 index 0000000..d74c3ab Binary files /dev/null and b/fuzz/corpus/alloc_ops/8539cbe302c3d9f38d50552c50061ec1702040d0 differ diff --git a/fuzz/corpus/alloc_ops/8577560c93f905fffcecc278643881352485373f b/fuzz/corpus/alloc_ops/8577560c93f905fffcecc278643881352485373f new file mode 100644 index 0000000..adcecda Binary files /dev/null and b/fuzz/corpus/alloc_ops/8577560c93f905fffcecc278643881352485373f differ diff --git a/fuzz/corpus/alloc_ops/857d3b7ff5d5eac0c0b692e48c721e70d059af2d b/fuzz/corpus/alloc_ops/857d3b7ff5d5eac0c0b692e48c721e70d059af2d new file mode 100644 index 0000000..5023c6f Binary files /dev/null and b/fuzz/corpus/alloc_ops/857d3b7ff5d5eac0c0b692e48c721e70d059af2d differ diff --git a/fuzz/corpus/alloc_ops/858b11634cd38ea56f0b71c95b84bf7d979d99bd b/fuzz/corpus/alloc_ops/858b11634cd38ea56f0b71c95b84bf7d979d99bd new file mode 100644 index 0000000..92b20d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/858b11634cd38ea56f0b71c95b84bf7d979d99bd differ diff --git a/fuzz/corpus/alloc_ops/85bbce06ea9343cc6bd4b3f5b827ff734e0af3f8 b/fuzz/corpus/alloc_ops/85bbce06ea9343cc6bd4b3f5b827ff734e0af3f8 new file mode 100644 index 0000000..5ad22c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/85bbce06ea9343cc6bd4b3f5b827ff734e0af3f8 differ diff --git a/fuzz/corpus/alloc_ops/862b3cfc78f351dd3abd9c7edae731264eb81009 b/fuzz/corpus/alloc_ops/862b3cfc78f351dd3abd9c7edae731264eb81009 new file mode 100644 index 0000000..1165169 Binary files /dev/null and b/fuzz/corpus/alloc_ops/862b3cfc78f351dd3abd9c7edae731264eb81009 differ diff --git a/fuzz/corpus/alloc_ops/8644eb433d0b61d869ec13dca3f5b5e6c460cb09 b/fuzz/corpus/alloc_ops/8644eb433d0b61d869ec13dca3f5b5e6c460cb09 new file mode 100644 index 0000000..c551201 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8644eb433d0b61d869ec13dca3f5b5e6c460cb09 differ diff --git a/fuzz/corpus/alloc_ops/866cf2529cd53850109844dfa76df6204d7c20e6 b/fuzz/corpus/alloc_ops/866cf2529cd53850109844dfa76df6204d7c20e6 new file mode 100644 index 0000000..52f1dd7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/866cf2529cd53850109844dfa76df6204d7c20e6 differ diff --git a/fuzz/corpus/alloc_ops/866fe19973d6c0d4bea17c65469b4ace76c1ecd9 b/fuzz/corpus/alloc_ops/866fe19973d6c0d4bea17c65469b4ace76c1ecd9 new file mode 100644 index 0000000..87713b6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/866fe19973d6c0d4bea17c65469b4ace76c1ecd9 differ diff --git a/fuzz/corpus/alloc_ops/8692d0e411ad627ebe521b8a690b77e8296b2489 b/fuzz/corpus/alloc_ops/8692d0e411ad627ebe521b8a690b77e8296b2489 new file mode 100644 index 0000000..870b06b Binary files /dev/null and b/fuzz/corpus/alloc_ops/8692d0e411ad627ebe521b8a690b77e8296b2489 differ diff --git a/fuzz/corpus/alloc_ops/86ccf0bcc7480698a5acbfdefddc172653dcd54e b/fuzz/corpus/alloc_ops/86ccf0bcc7480698a5acbfdefddc172653dcd54e new file mode 100644 index 0000000..4702659 --- /dev/null +++ b/fuzz/corpus/alloc_ops/86ccf0bcc7480698a5acbfdefddc172653dcd54e @@ -0,0 +1 @@ +ö­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­a­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/86d05f0eea0dcae9ec7c5967ce4abf4fd59d4a59 b/fuzz/corpus/alloc_ops/86d05f0eea0dcae9ec7c5967ce4abf4fd59d4a59 new file mode 100644 index 0000000..ca31d8c Binary files /dev/null and b/fuzz/corpus/alloc_ops/86d05f0eea0dcae9ec7c5967ce4abf4fd59d4a59 differ diff --git a/fuzz/corpus/alloc_ops/8703290f6f20b8666614deaefe4065edb2caf025 b/fuzz/corpus/alloc_ops/8703290f6f20b8666614deaefe4065edb2caf025 new file mode 100644 index 0000000..cae6bac Binary files /dev/null and b/fuzz/corpus/alloc_ops/8703290f6f20b8666614deaefe4065edb2caf025 differ diff --git a/fuzz/corpus/alloc_ops/87900ec7adbea7cc0221830b4e132de2b605587a b/fuzz/corpus/alloc_ops/87900ec7adbea7cc0221830b4e132de2b605587a new file mode 100644 index 0000000..d055314 Binary files /dev/null and b/fuzz/corpus/alloc_ops/87900ec7adbea7cc0221830b4e132de2b605587a differ diff --git a/fuzz/corpus/alloc_ops/87de2bd64012e0bbd100d364a7c4374c18a681d1 b/fuzz/corpus/alloc_ops/87de2bd64012e0bbd100d364a7c4374c18a681d1 new file mode 100644 index 0000000..7edec23 Binary files /dev/null and b/fuzz/corpus/alloc_ops/87de2bd64012e0bbd100d364a7c4374c18a681d1 differ diff --git a/fuzz/corpus/alloc_ops/8804a013038d090b0be496d38b1447fd435db39c b/fuzz/corpus/alloc_ops/8804a013038d090b0be496d38b1447fd435db39c new file mode 100644 index 0000000..63b43d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8804a013038d090b0be496d38b1447fd435db39c differ diff --git a/fuzz/corpus/alloc_ops/8825ff057b1d72b8b3d9e757197c602d22c12c4d b/fuzz/corpus/alloc_ops/8825ff057b1d72b8b3d9e757197c602d22c12c4d new file mode 100644 index 0000000..d9c8eee Binary files /dev/null and b/fuzz/corpus/alloc_ops/8825ff057b1d72b8b3d9e757197c602d22c12c4d differ diff --git a/fuzz/corpus/alloc_ops/88815723ac83232cbae893431956eb124497df71 b/fuzz/corpus/alloc_ops/88815723ac83232cbae893431956eb124497df71 new file mode 100644 index 0000000..d51b584 Binary files /dev/null and b/fuzz/corpus/alloc_ops/88815723ac83232cbae893431956eb124497df71 differ diff --git a/fuzz/corpus/alloc_ops/888e86f1843a1da0cd7398a976a5dc9aed9da711 b/fuzz/corpus/alloc_ops/888e86f1843a1da0cd7398a976a5dc9aed9da711 new file mode 100644 index 0000000..bf6192f Binary files /dev/null and b/fuzz/corpus/alloc_ops/888e86f1843a1da0cd7398a976a5dc9aed9da711 differ diff --git a/fuzz/corpus/alloc_ops/8890fa4ce3076fe5d14ed647f4e65ce451c2106a b/fuzz/corpus/alloc_ops/8890fa4ce3076fe5d14ed647f4e65ce451c2106a new file mode 100644 index 0000000..09f64e6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8890fa4ce3076fe5d14ed647f4e65ce451c2106a differ diff --git a/fuzz/corpus/alloc_ops/88dbfbe547e142b76f51a821b929897bc525c7ae b/fuzz/corpus/alloc_ops/88dbfbe547e142b76f51a821b929897bc525c7ae new file mode 100644 index 0000000..dafa317 Binary files /dev/null and b/fuzz/corpus/alloc_ops/88dbfbe547e142b76f51a821b929897bc525c7ae differ diff --git a/fuzz/corpus/alloc_ops/88e0ad19718ed5398285dbca0e575857ab5d021a b/fuzz/corpus/alloc_ops/88e0ad19718ed5398285dbca0e575857ab5d021a new file mode 100644 index 0000000..bb21bac Binary files /dev/null and b/fuzz/corpus/alloc_ops/88e0ad19718ed5398285dbca0e575857ab5d021a differ diff --git a/fuzz/corpus/alloc_ops/88f9885c99d905af082199512289b7a0c91abc27 b/fuzz/corpus/alloc_ops/88f9885c99d905af082199512289b7a0c91abc27 new file mode 100644 index 0000000..109a14e Binary files /dev/null and b/fuzz/corpus/alloc_ops/88f9885c99d905af082199512289b7a0c91abc27 differ diff --git a/fuzz/corpus/alloc_ops/89232fe8d7a3fd971e76e070ef5913ec87d7ef62 b/fuzz/corpus/alloc_ops/89232fe8d7a3fd971e76e070ef5913ec87d7ef62 new file mode 100644 index 0000000..7c0f996 Binary files /dev/null and b/fuzz/corpus/alloc_ops/89232fe8d7a3fd971e76e070ef5913ec87d7ef62 differ diff --git a/fuzz/corpus/alloc_ops/8943ddba067d997718b0c288ab4850cfe8a0ae06 b/fuzz/corpus/alloc_ops/8943ddba067d997718b0c288ab4850cfe8a0ae06 new file mode 100644 index 0000000..f621ddb Binary files /dev/null and b/fuzz/corpus/alloc_ops/8943ddba067d997718b0c288ab4850cfe8a0ae06 differ diff --git a/fuzz/corpus/alloc_ops/8981221d0e398409245e1c387da2264ef1112be9 b/fuzz/corpus/alloc_ops/8981221d0e398409245e1c387da2264ef1112be9 new file mode 100644 index 0000000..93b5e8a Binary files /dev/null and b/fuzz/corpus/alloc_ops/8981221d0e398409245e1c387da2264ef1112be9 differ diff --git a/fuzz/corpus/alloc_ops/89b6b5a3e052817adbc67ef479f281cc4a0c2dce b/fuzz/corpus/alloc_ops/89b6b5a3e052817adbc67ef479f281cc4a0c2dce new file mode 100644 index 0000000..20e95c5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/89b6b5a3e052817adbc67ef479f281cc4a0c2dce differ diff --git a/fuzz/corpus/alloc_ops/8a0da6a56e87bfe16c00b2a9fe68b6844be7216c b/fuzz/corpus/alloc_ops/8a0da6a56e87bfe16c00b2a9fe68b6844be7216c new file mode 100644 index 0000000..5ed3670 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a0da6a56e87bfe16c00b2a9fe68b6844be7216c differ diff --git a/fuzz/corpus/alloc_ops/8a1ed3d7b734eb1ce15ddf6cac85c5ed3e324938 b/fuzz/corpus/alloc_ops/8a1ed3d7b734eb1ce15ddf6cac85c5ed3e324938 new file mode 100644 index 0000000..0f7a93b Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a1ed3d7b734eb1ce15ddf6cac85c5ed3e324938 differ diff --git a/fuzz/corpus/alloc_ops/8a2bc129e145295336af3140972cbd0604da6171 b/fuzz/corpus/alloc_ops/8a2bc129e145295336af3140972cbd0604da6171 new file mode 100644 index 0000000..648ecd9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a2bc129e145295336af3140972cbd0604da6171 differ diff --git a/fuzz/corpus/alloc_ops/8a35f35c85fc08f93eefb66944cb7f5c84fc5686 b/fuzz/corpus/alloc_ops/8a35f35c85fc08f93eefb66944cb7f5c84fc5686 new file mode 100644 index 0000000..9f63dc8 --- /dev/null +++ b/fuzz/corpus/alloc_ops/8a35f35c85fc08f93eefb66944cb7f5c84fc5686 @@ -0,0 +1 @@ +%€ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/8a5222634f919b9283656e7df068be7d0de6838d b/fuzz/corpus/alloc_ops/8a5222634f919b9283656e7df068be7d0de6838d new file mode 100644 index 0000000..9225a32 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a5222634f919b9283656e7df068be7d0de6838d differ diff --git a/fuzz/corpus/alloc_ops/8a687aaa41f945c5be7be3424adc6e07f8db5e01 b/fuzz/corpus/alloc_ops/8a687aaa41f945c5be7be3424adc6e07f8db5e01 new file mode 100644 index 0000000..1a28e40 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a687aaa41f945c5be7be3424adc6e07f8db5e01 differ diff --git a/fuzz/corpus/alloc_ops/8a6b91975f8379cd0becab385f6927209f6236a1 b/fuzz/corpus/alloc_ops/8a6b91975f8379cd0becab385f6927209f6236a1 new file mode 100644 index 0000000..8c92db1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8a6b91975f8379cd0becab385f6927209f6236a1 differ diff --git a/fuzz/corpus/alloc_ops/8ac4b1aa4e36eb5becc8b7a57b8e6a820ed3658a b/fuzz/corpus/alloc_ops/8ac4b1aa4e36eb5becc8b7a57b8e6a820ed3658a new file mode 100644 index 0000000..25a3581 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8ac4b1aa4e36eb5becc8b7a57b8e6a820ed3658a differ diff --git a/fuzz/corpus/alloc_ops/8aff83233e630a93f81df0ce03f460928cc3c3d4 b/fuzz/corpus/alloc_ops/8aff83233e630a93f81df0ce03f460928cc3c3d4 new file mode 100644 index 0000000..dc88272 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8aff83233e630a93f81df0ce03f460928cc3c3d4 differ diff --git a/fuzz/corpus/alloc_ops/8b09ab9ac62a3bd01cd76d7b848bb3c10cd417aa b/fuzz/corpus/alloc_ops/8b09ab9ac62a3bd01cd76d7b848bb3c10cd417aa new file mode 100644 index 0000000..8045093 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8b09ab9ac62a3bd01cd76d7b848bb3c10cd417aa differ diff --git a/fuzz/corpus/alloc_ops/8b5cdd3048cb72b7b74c671df585d20c75b340fe b/fuzz/corpus/alloc_ops/8b5cdd3048cb72b7b74c671df585d20c75b340fe new file mode 100644 index 0000000..c7b3e3d Binary files /dev/null and b/fuzz/corpus/alloc_ops/8b5cdd3048cb72b7b74c671df585d20c75b340fe differ diff --git a/fuzz/corpus/alloc_ops/8b5fcd2da3ba08249595710755c40ada2a3436f7 b/fuzz/corpus/alloc_ops/8b5fcd2da3ba08249595710755c40ada2a3436f7 new file mode 100644 index 0000000..6d5eff8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8b5fcd2da3ba08249595710755c40ada2a3436f7 differ diff --git a/fuzz/corpus/alloc_ops/8bb1b2fea1d414de392842be9329a4dd3f145124 b/fuzz/corpus/alloc_ops/8bb1b2fea1d414de392842be9329a4dd3f145124 new file mode 100644 index 0000000..2c6c856 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8bb1b2fea1d414de392842be9329a4dd3f145124 differ diff --git a/fuzz/corpus/alloc_ops/8bf75d5b95d2dd846f6d22e12168e1e4d4b390fa b/fuzz/corpus/alloc_ops/8bf75d5b95d2dd846f6d22e12168e1e4d4b390fa new file mode 100644 index 0000000..5a6b128 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8bf75d5b95d2dd846f6d22e12168e1e4d4b390fa differ diff --git a/fuzz/corpus/alloc_ops/8bf9d7c5de7f7b2e4095aac2987fb0bb5590b72f b/fuzz/corpus/alloc_ops/8bf9d7c5de7f7b2e4095aac2987fb0bb5590b72f new file mode 100644 index 0000000..2f6d8ca Binary files /dev/null and b/fuzz/corpus/alloc_ops/8bf9d7c5de7f7b2e4095aac2987fb0bb5590b72f differ diff --git a/fuzz/corpus/alloc_ops/8bfd503ab381acd1bb4b2a8f218b8c31ab003323 b/fuzz/corpus/alloc_ops/8bfd503ab381acd1bb4b2a8f218b8c31ab003323 new file mode 100644 index 0000000..c91980a Binary files /dev/null and b/fuzz/corpus/alloc_ops/8bfd503ab381acd1bb4b2a8f218b8c31ab003323 differ diff --git a/fuzz/corpus/alloc_ops/8d10c43de209b59ff2e12900489b9b70c2ce8eab b/fuzz/corpus/alloc_ops/8d10c43de209b59ff2e12900489b9b70c2ce8eab new file mode 100644 index 0000000..d438aea Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d10c43de209b59ff2e12900489b9b70c2ce8eab differ diff --git a/fuzz/corpus/alloc_ops/8d473f298c751181b18fa1baf55e0c458366404d b/fuzz/corpus/alloc_ops/8d473f298c751181b18fa1baf55e0c458366404d new file mode 100644 index 0000000..0c93c63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d473f298c751181b18fa1baf55e0c458366404d differ diff --git a/fuzz/corpus/alloc_ops/8d5311aef36ca2a37d541c486fcaffd3ab7766cd b/fuzz/corpus/alloc_ops/8d5311aef36ca2a37d541c486fcaffd3ab7766cd new file mode 100644 index 0000000..7db2126 --- /dev/null +++ b/fuzz/corpus/alloc_ops/8d5311aef36ca2a37d541c486fcaffd3ab7766cd @@ -0,0 +1 @@ +öÜÿ2ûß \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/8d5695067d8f2701d18a0d7ae14d3e3e6c3a3a64 b/fuzz/corpus/alloc_ops/8d5695067d8f2701d18a0d7ae14d3e3e6c3a3a64 new file mode 100644 index 0000000..7d1fa5d Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d5695067d8f2701d18a0d7ae14d3e3e6c3a3a64 differ diff --git a/fuzz/corpus/alloc_ops/8d6394bb3f38f7f446a0840fc562f1b6f88ab9bd b/fuzz/corpus/alloc_ops/8d6394bb3f38f7f446a0840fc562f1b6f88ab9bd new file mode 100644 index 0000000..0abfeb8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d6394bb3f38f7f446a0840fc562f1b6f88ab9bd differ diff --git a/fuzz/corpus/alloc_ops/8d6482b9668f2bbf26dec63477e4ad97b9c81c21 b/fuzz/corpus/alloc_ops/8d6482b9668f2bbf26dec63477e4ad97b9c81c21 new file mode 100644 index 0000000..3963cff Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d6482b9668f2bbf26dec63477e4ad97b9c81c21 differ diff --git a/fuzz/corpus/alloc_ops/8d728833a06b3b317fb55c3b282fa04bfa2464f8 b/fuzz/corpus/alloc_ops/8d728833a06b3b317fb55c3b282fa04bfa2464f8 new file mode 100644 index 0000000..e1dcf86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d728833a06b3b317fb55c3b282fa04bfa2464f8 differ diff --git a/fuzz/corpus/alloc_ops/8d7886398e4254c09e7be31f4b0d5632297559dc b/fuzz/corpus/alloc_ops/8d7886398e4254c09e7be31f4b0d5632297559dc new file mode 100644 index 0000000..29f52f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d7886398e4254c09e7be31f4b0d5632297559dc differ diff --git a/fuzz/corpus/alloc_ops/8d7cdf24458a6da5b21ecfd66f31e6b290f639bb b/fuzz/corpus/alloc_ops/8d7cdf24458a6da5b21ecfd66f31e6b290f639bb new file mode 100644 index 0000000..2f25194 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d7cdf24458a6da5b21ecfd66f31e6b290f639bb differ diff --git a/fuzz/corpus/alloc_ops/8d9ea4fda95faea2571116a030a2d65d31b2302c b/fuzz/corpus/alloc_ops/8d9ea4fda95faea2571116a030a2d65d31b2302c new file mode 100644 index 0000000..73c0861 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8d9ea4fda95faea2571116a030a2d65d31b2302c differ diff --git a/fuzz/corpus/alloc_ops/8dfa18f52a1a856b4288f295bb2078d454f647fa b/fuzz/corpus/alloc_ops/8dfa18f52a1a856b4288f295bb2078d454f647fa new file mode 100644 index 0000000..9d115ec Binary files /dev/null and b/fuzz/corpus/alloc_ops/8dfa18f52a1a856b4288f295bb2078d454f647fa differ diff --git a/fuzz/corpus/alloc_ops/8e199278a130fa2943e90e260014e341b1fd92f8 b/fuzz/corpus/alloc_ops/8e199278a130fa2943e90e260014e341b1fd92f8 new file mode 100644 index 0000000..e6428c4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8e199278a130fa2943e90e260014e341b1fd92f8 differ diff --git a/fuzz/corpus/alloc_ops/8e3a20052edefda0dee6b7d345fc725132cd3eac b/fuzz/corpus/alloc_ops/8e3a20052edefda0dee6b7d345fc725132cd3eac new file mode 100644 index 0000000..75f297a Binary files /dev/null and b/fuzz/corpus/alloc_ops/8e3a20052edefda0dee6b7d345fc725132cd3eac differ diff --git a/fuzz/corpus/alloc_ops/8e4079f64128795bcdb966c26c687581c8947cc8 b/fuzz/corpus/alloc_ops/8e4079f64128795bcdb966c26c687581c8947cc8 new file mode 100644 index 0000000..b305d43 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8e4079f64128795bcdb966c26c687581c8947cc8 differ diff --git a/fuzz/corpus/alloc_ops/8f0ed819ef9084ef8885b5266ac47bc6df949535 b/fuzz/corpus/alloc_ops/8f0ed819ef9084ef8885b5266ac47bc6df949535 new file mode 100644 index 0000000..914f683 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8f0ed819ef9084ef8885b5266ac47bc6df949535 differ diff --git a/fuzz/corpus/alloc_ops/8f13c6fbfa853686f183365d54938f05c038b80e b/fuzz/corpus/alloc_ops/8f13c6fbfa853686f183365d54938f05c038b80e new file mode 100644 index 0000000..55557fe Binary files /dev/null and b/fuzz/corpus/alloc_ops/8f13c6fbfa853686f183365d54938f05c038b80e differ diff --git a/fuzz/corpus/alloc_ops/8f4c085a1b9f575a31396cbd13ed253706ec220a b/fuzz/corpus/alloc_ops/8f4c085a1b9f575a31396cbd13ed253706ec220a new file mode 100644 index 0000000..d657f54 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8f4c085a1b9f575a31396cbd13ed253706ec220a differ diff --git a/fuzz/corpus/alloc_ops/8f55de8ace3bd0edf712e913fe53ede69f83cb7f b/fuzz/corpus/alloc_ops/8f55de8ace3bd0edf712e913fe53ede69f83cb7f new file mode 100644 index 0000000..02e0e9b Binary files /dev/null and b/fuzz/corpus/alloc_ops/8f55de8ace3bd0edf712e913fe53ede69f83cb7f differ diff --git a/fuzz/corpus/alloc_ops/8f9ba230ec30a1600e133039da574bea9ee66a25 b/fuzz/corpus/alloc_ops/8f9ba230ec30a1600e133039da574bea9ee66a25 new file mode 100644 index 0000000..5c0d475 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8f9ba230ec30a1600e133039da574bea9ee66a25 differ diff --git a/fuzz/corpus/alloc_ops/8fed5b7f884ae4aa9f709ebc9fdc2a303af03b22 b/fuzz/corpus/alloc_ops/8fed5b7f884ae4aa9f709ebc9fdc2a303af03b22 new file mode 100644 index 0000000..f7fb889 Binary files /dev/null and b/fuzz/corpus/alloc_ops/8fed5b7f884ae4aa9f709ebc9fdc2a303af03b22 differ diff --git a/fuzz/corpus/alloc_ops/8ff4c19e7ea8bf5df6de4924febb42d5ed04779f b/fuzz/corpus/alloc_ops/8ff4c19e7ea8bf5df6de4924febb42d5ed04779f new file mode 100644 index 0000000..07c161a Binary files /dev/null and b/fuzz/corpus/alloc_ops/8ff4c19e7ea8bf5df6de4924febb42d5ed04779f differ diff --git a/fuzz/corpus/alloc_ops/905a075e1c2cefa7c6f7a77466af6eb6d9fe1f3f b/fuzz/corpus/alloc_ops/905a075e1c2cefa7c6f7a77466af6eb6d9fe1f3f new file mode 100644 index 0000000..876b051 Binary files /dev/null and b/fuzz/corpus/alloc_ops/905a075e1c2cefa7c6f7a77466af6eb6d9fe1f3f differ diff --git a/fuzz/corpus/alloc_ops/9100a791fc7185031f2dd6a67102d39267492817 b/fuzz/corpus/alloc_ops/9100a791fc7185031f2dd6a67102d39267492817 new file mode 100644 index 0000000..ca969e5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9100a791fc7185031f2dd6a67102d39267492817 differ diff --git a/fuzz/corpus/alloc_ops/9104483ccdd01eff7f0f78d49337730d2cc7a09e b/fuzz/corpus/alloc_ops/9104483ccdd01eff7f0f78d49337730d2cc7a09e new file mode 100644 index 0000000..950ee15 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9104483ccdd01eff7f0f78d49337730d2cc7a09e differ diff --git a/fuzz/corpus/alloc_ops/9120e7bc80487d4f7a549c2454970f8cf5fb13da b/fuzz/corpus/alloc_ops/9120e7bc80487d4f7a549c2454970f8cf5fb13da new file mode 100644 index 0000000..80acdab Binary files /dev/null and b/fuzz/corpus/alloc_ops/9120e7bc80487d4f7a549c2454970f8cf5fb13da differ diff --git a/fuzz/corpus/alloc_ops/9181394b0c6d5c81ef1346c9ff108642cf01f1cf b/fuzz/corpus/alloc_ops/9181394b0c6d5c81ef1346c9ff108642cf01f1cf new file mode 100644 index 0000000..025ce76 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9181394b0c6d5c81ef1346c9ff108642cf01f1cf differ diff --git a/fuzz/corpus/alloc_ops/91908c4b745a1ba7bab359f8e790acc38ab06738 b/fuzz/corpus/alloc_ops/91908c4b745a1ba7bab359f8e790acc38ab06738 new file mode 100644 index 0000000..1783cdf Binary files /dev/null and b/fuzz/corpus/alloc_ops/91908c4b745a1ba7bab359f8e790acc38ab06738 differ diff --git a/fuzz/corpus/alloc_ops/91e8eb4cc06113543d70c371b394b9fa7c63873e b/fuzz/corpus/alloc_ops/91e8eb4cc06113543d70c371b394b9fa7c63873e new file mode 100644 index 0000000..212f095 Binary files /dev/null and b/fuzz/corpus/alloc_ops/91e8eb4cc06113543d70c371b394b9fa7c63873e differ diff --git a/fuzz/corpus/alloc_ops/91f49550979dc8342935a5e643233c5bb093fcc6 b/fuzz/corpus/alloc_ops/91f49550979dc8342935a5e643233c5bb093fcc6 new file mode 100644 index 0000000..90eebe4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/91f49550979dc8342935a5e643233c5bb093fcc6 differ diff --git a/fuzz/corpus/alloc_ops/920f1ff06035f72d82ac4e530b342af30e09f2cb b/fuzz/corpus/alloc_ops/920f1ff06035f72d82ac4e530b342af30e09f2cb new file mode 100644 index 0000000..b31b186 Binary files /dev/null and b/fuzz/corpus/alloc_ops/920f1ff06035f72d82ac4e530b342af30e09f2cb differ diff --git a/fuzz/corpus/alloc_ops/92253f6821f7dd43a03a4fb284cb2089071e371e b/fuzz/corpus/alloc_ops/92253f6821f7dd43a03a4fb284cb2089071e371e new file mode 100644 index 0000000..74f1389 Binary files /dev/null and b/fuzz/corpus/alloc_ops/92253f6821f7dd43a03a4fb284cb2089071e371e differ diff --git a/fuzz/corpus/alloc_ops/92647139cc7e0631b8b4987d5df2d74cf1ca6426 b/fuzz/corpus/alloc_ops/92647139cc7e0631b8b4987d5df2d74cf1ca6426 new file mode 100644 index 0000000..e9cec9a Binary files /dev/null and b/fuzz/corpus/alloc_ops/92647139cc7e0631b8b4987d5df2d74cf1ca6426 differ diff --git a/fuzz/corpus/alloc_ops/9288f568b0f86c8baecdbd0a82274f355f9b10b2 b/fuzz/corpus/alloc_ops/9288f568b0f86c8baecdbd0a82274f355f9b10b2 new file mode 100644 index 0000000..0269529 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9288f568b0f86c8baecdbd0a82274f355f9b10b2 differ diff --git a/fuzz/corpus/alloc_ops/929e88704057ffa35640610d944e92c4c815e743 b/fuzz/corpus/alloc_ops/929e88704057ffa35640610d944e92c4c815e743 new file mode 100644 index 0000000..815d3cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/929e88704057ffa35640610d944e92c4c815e743 differ diff --git a/fuzz/corpus/alloc_ops/92b6eef44062661538c37fc01dc8b5fe50ed2aae b/fuzz/corpus/alloc_ops/92b6eef44062661538c37fc01dc8b5fe50ed2aae new file mode 100644 index 0000000..356ac89 Binary files /dev/null and b/fuzz/corpus/alloc_ops/92b6eef44062661538c37fc01dc8b5fe50ed2aae differ diff --git a/fuzz/corpus/alloc_ops/92ba45a18a7562f786a87bacc03de0f4650bac58 b/fuzz/corpus/alloc_ops/92ba45a18a7562f786a87bacc03de0f4650bac58 new file mode 100644 index 0000000..8a3ed83 Binary files /dev/null and b/fuzz/corpus/alloc_ops/92ba45a18a7562f786a87bacc03de0f4650bac58 differ diff --git a/fuzz/corpus/alloc_ops/92d13c64b8cddde864cee8220b5a6a803f1f5c07 b/fuzz/corpus/alloc_ops/92d13c64b8cddde864cee8220b5a6a803f1f5c07 new file mode 100644 index 0000000..2747e0d Binary files /dev/null and b/fuzz/corpus/alloc_ops/92d13c64b8cddde864cee8220b5a6a803f1f5c07 differ diff --git a/fuzz/corpus/alloc_ops/92eee384be0f26643659e4485a9898755012ad90 b/fuzz/corpus/alloc_ops/92eee384be0f26643659e4485a9898755012ad90 new file mode 100644 index 0000000..c02b6c3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/92eee384be0f26643659e4485a9898755012ad90 differ diff --git a/fuzz/corpus/alloc_ops/9304853d1311453e73173da11f95c81adddfd7a2 b/fuzz/corpus/alloc_ops/9304853d1311453e73173da11f95c81adddfd7a2 new file mode 100644 index 0000000..4ce111d Binary files /dev/null and b/fuzz/corpus/alloc_ops/9304853d1311453e73173da11f95c81adddfd7a2 differ diff --git a/fuzz/corpus/alloc_ops/935c783417f472b0cf52217a39e13bd4893de9af b/fuzz/corpus/alloc_ops/935c783417f472b0cf52217a39e13bd4893de9af new file mode 100644 index 0000000..cf70ec4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/935c783417f472b0cf52217a39e13bd4893de9af differ diff --git a/fuzz/corpus/alloc_ops/938976ced35570b7618f840ea30e74cfa1a7d0a4 b/fuzz/corpus/alloc_ops/938976ced35570b7618f840ea30e74cfa1a7d0a4 new file mode 100644 index 0000000..3fc478b Binary files /dev/null and b/fuzz/corpus/alloc_ops/938976ced35570b7618f840ea30e74cfa1a7d0a4 differ diff --git a/fuzz/corpus/alloc_ops/93a949af31c5f2f2cd0f67e878d49cc5896ac236 b/fuzz/corpus/alloc_ops/93a949af31c5f2f2cd0f67e878d49cc5896ac236 new file mode 100644 index 0000000..05da624 Binary files /dev/null and b/fuzz/corpus/alloc_ops/93a949af31c5f2f2cd0f67e878d49cc5896ac236 differ diff --git a/fuzz/corpus/alloc_ops/93c98ef4d50366cacb8ba8702868ca21e6063207 b/fuzz/corpus/alloc_ops/93c98ef4d50366cacb8ba8702868ca21e6063207 new file mode 100644 index 0000000..dbad400 Binary files /dev/null and b/fuzz/corpus/alloc_ops/93c98ef4d50366cacb8ba8702868ca21e6063207 differ diff --git a/fuzz/corpus/alloc_ops/93e3f12135eac8b82d0fc1847e3642d00ce39771 b/fuzz/corpus/alloc_ops/93e3f12135eac8b82d0fc1847e3642d00ce39771 new file mode 100644 index 0000000..f1c7cd9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/93e3f12135eac8b82d0fc1847e3642d00ce39771 differ diff --git a/fuzz/corpus/alloc_ops/940da1cff97ec345cdd482a018127bba714656ed b/fuzz/corpus/alloc_ops/940da1cff97ec345cdd482a018127bba714656ed new file mode 100644 index 0000000..aaae69f Binary files /dev/null and b/fuzz/corpus/alloc_ops/940da1cff97ec345cdd482a018127bba714656ed differ diff --git a/fuzz/corpus/alloc_ops/942037fb91725e6b725178fe76546a5c9f270738 b/fuzz/corpus/alloc_ops/942037fb91725e6b725178fe76546a5c9f270738 new file mode 100644 index 0000000..86b2c99 Binary files /dev/null and b/fuzz/corpus/alloc_ops/942037fb91725e6b725178fe76546a5c9f270738 differ diff --git a/fuzz/corpus/alloc_ops/9457db79bfbc937ffa27a98ec89258704b1ad752 b/fuzz/corpus/alloc_ops/9457db79bfbc937ffa27a98ec89258704b1ad752 new file mode 100644 index 0000000..1dba0bc Binary files /dev/null and b/fuzz/corpus/alloc_ops/9457db79bfbc937ffa27a98ec89258704b1ad752 differ diff --git a/fuzz/corpus/alloc_ops/94733bc10c434ca289d0f19e42889cee172e7c1d b/fuzz/corpus/alloc_ops/94733bc10c434ca289d0f19e42889cee172e7c1d new file mode 100644 index 0000000..d7e5d09 Binary files /dev/null and b/fuzz/corpus/alloc_ops/94733bc10c434ca289d0f19e42889cee172e7c1d differ diff --git a/fuzz/corpus/alloc_ops/94980d33a58cbe771b102865f7b9043b4c25bb1c b/fuzz/corpus/alloc_ops/94980d33a58cbe771b102865f7b9043b4c25bb1c new file mode 100644 index 0000000..a0fbdac Binary files /dev/null and b/fuzz/corpus/alloc_ops/94980d33a58cbe771b102865f7b9043b4c25bb1c differ diff --git a/fuzz/corpus/alloc_ops/94e63da97692ee9c57c3875336c967c0b6a407f2 b/fuzz/corpus/alloc_ops/94e63da97692ee9c57c3875336c967c0b6a407f2 new file mode 100644 index 0000000..9e3139d Binary files /dev/null and b/fuzz/corpus/alloc_ops/94e63da97692ee9c57c3875336c967c0b6a407f2 differ diff --git a/fuzz/corpus/alloc_ops/951922be95bf40c8d0afa5703c1e715bf0a95357 b/fuzz/corpus/alloc_ops/951922be95bf40c8d0afa5703c1e715bf0a95357 new file mode 100644 index 0000000..64aa42f Binary files /dev/null and b/fuzz/corpus/alloc_ops/951922be95bf40c8d0afa5703c1e715bf0a95357 differ diff --git a/fuzz/corpus/alloc_ops/95a1416ae9c6e7860550724ef4023185b95d2643 b/fuzz/corpus/alloc_ops/95a1416ae9c6e7860550724ef4023185b95d2643 new file mode 100644 index 0000000..5273644 Binary files /dev/null and b/fuzz/corpus/alloc_ops/95a1416ae9c6e7860550724ef4023185b95d2643 differ diff --git a/fuzz/corpus/alloc_ops/95c32a8fbd41400f289c3fb4669c53920cd8230d b/fuzz/corpus/alloc_ops/95c32a8fbd41400f289c3fb4669c53920cd8230d new file mode 100644 index 0000000..607a5b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/95c32a8fbd41400f289c3fb4669c53920cd8230d differ diff --git a/fuzz/corpus/alloc_ops/95f35bfe2934a8b3004dd0e52f926d1612d3decc b/fuzz/corpus/alloc_ops/95f35bfe2934a8b3004dd0e52f926d1612d3decc new file mode 100644 index 0000000..33b9edc --- /dev/null +++ b/fuzz/corpus/alloc_ops/95f35bfe2934a8b3004dd0e52f926d1612d3decc @@ -0,0 +1 @@ +ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýý££££££££££££££££££££££££+££££££££££££££££££££££££ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýýý \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/9694c4ebd673a5e2fd26e4b2e64f92e914ebd95f b/fuzz/corpus/alloc_ops/9694c4ebd673a5e2fd26e4b2e64f92e914ebd95f new file mode 100644 index 0000000..cb43b5c Binary files /dev/null and b/fuzz/corpus/alloc_ops/9694c4ebd673a5e2fd26e4b2e64f92e914ebd95f differ diff --git a/fuzz/corpus/alloc_ops/96c1eaae9712a49432d27eac8f036f881297f8a7 b/fuzz/corpus/alloc_ops/96c1eaae9712a49432d27eac8f036f881297f8a7 new file mode 100644 index 0000000..bcc0a2b Binary files /dev/null and b/fuzz/corpus/alloc_ops/96c1eaae9712a49432d27eac8f036f881297f8a7 differ diff --git a/fuzz/corpus/alloc_ops/96d5bd9ca5574a45d81a6d934ccae60a6a2fe4b7 b/fuzz/corpus/alloc_ops/96d5bd9ca5574a45d81a6d934ccae60a6a2fe4b7 new file mode 100644 index 0000000..815ea25 Binary files /dev/null and b/fuzz/corpus/alloc_ops/96d5bd9ca5574a45d81a6d934ccae60a6a2fe4b7 differ diff --git a/fuzz/corpus/alloc_ops/96f28646c5806334ba2b48ed700dd7740d471782 b/fuzz/corpus/alloc_ops/96f28646c5806334ba2b48ed700dd7740d471782 new file mode 100644 index 0000000..13c066f Binary files /dev/null and b/fuzz/corpus/alloc_ops/96f28646c5806334ba2b48ed700dd7740d471782 differ diff --git a/fuzz/corpus/alloc_ops/96f47cebf0844dc26ad4c74c408ad645d8c6ef14 b/fuzz/corpus/alloc_ops/96f47cebf0844dc26ad4c74c408ad645d8c6ef14 new file mode 100644 index 0000000..c40a132 Binary files /dev/null and b/fuzz/corpus/alloc_ops/96f47cebf0844dc26ad4c74c408ad645d8c6ef14 differ diff --git a/fuzz/corpus/alloc_ops/96f89d030cd1b3a2d808cbcf72cc15bb238c787e b/fuzz/corpus/alloc_ops/96f89d030cd1b3a2d808cbcf72cc15bb238c787e new file mode 100644 index 0000000..f19577f Binary files /dev/null and b/fuzz/corpus/alloc_ops/96f89d030cd1b3a2d808cbcf72cc15bb238c787e differ diff --git a/fuzz/corpus/alloc_ops/96f915ff5150eb2636a814fa2b3aaabb82ab4e7d b/fuzz/corpus/alloc_ops/96f915ff5150eb2636a814fa2b3aaabb82ab4e7d new file mode 100644 index 0000000..594670b Binary files /dev/null and b/fuzz/corpus/alloc_ops/96f915ff5150eb2636a814fa2b3aaabb82ab4e7d differ diff --git a/fuzz/corpus/alloc_ops/97063e1361656a03529aba7b87f72510939d0666 b/fuzz/corpus/alloc_ops/97063e1361656a03529aba7b87f72510939d0666 new file mode 100644 index 0000000..1038741 Binary files /dev/null and b/fuzz/corpus/alloc_ops/97063e1361656a03529aba7b87f72510939d0666 differ diff --git a/fuzz/corpus/alloc_ops/972ba929aaa5698c5736ff549e031d28088cac7d b/fuzz/corpus/alloc_ops/972ba929aaa5698c5736ff549e031d28088cac7d new file mode 100644 index 0000000..1564971 Binary files /dev/null and b/fuzz/corpus/alloc_ops/972ba929aaa5698c5736ff549e031d28088cac7d differ diff --git a/fuzz/corpus/alloc_ops/972c2203b4318bcecb108e3f9d9aeeaa132b9a27 b/fuzz/corpus/alloc_ops/972c2203b4318bcecb108e3f9d9aeeaa132b9a27 new file mode 100644 index 0000000..1e73115 Binary files /dev/null and b/fuzz/corpus/alloc_ops/972c2203b4318bcecb108e3f9d9aeeaa132b9a27 differ diff --git a/fuzz/corpus/alloc_ops/97335b657e536a1378178e163de7091b1da32e48 b/fuzz/corpus/alloc_ops/97335b657e536a1378178e163de7091b1da32e48 new file mode 100644 index 0000000..55e8f0d Binary files /dev/null and b/fuzz/corpus/alloc_ops/97335b657e536a1378178e163de7091b1da32e48 differ diff --git a/fuzz/corpus/alloc_ops/9734dad68917dd29c6eacbcc98e76e22cdc0dd61 b/fuzz/corpus/alloc_ops/9734dad68917dd29c6eacbcc98e76e22cdc0dd61 new file mode 100644 index 0000000..81c88c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9734dad68917dd29c6eacbcc98e76e22cdc0dd61 differ diff --git a/fuzz/corpus/alloc_ops/9752d532fac5c102c54d01aefc2abdf621cde767 b/fuzz/corpus/alloc_ops/9752d532fac5c102c54d01aefc2abdf621cde767 new file mode 100644 index 0000000..cd0bb43 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9752d532fac5c102c54d01aefc2abdf621cde767 differ diff --git a/fuzz/corpus/alloc_ops/97544c5bd3403b7ca9a30458b79c54d19447dc94 b/fuzz/corpus/alloc_ops/97544c5bd3403b7ca9a30458b79c54d19447dc94 new file mode 100644 index 0000000..854b3b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/97544c5bd3403b7ca9a30458b79c54d19447dc94 differ diff --git a/fuzz/corpus/alloc_ops/97546b42b2f825dc2a9ccb33c19beaa6fa44191e b/fuzz/corpus/alloc_ops/97546b42b2f825dc2a9ccb33c19beaa6fa44191e new file mode 100644 index 0000000..2e7713a Binary files /dev/null and b/fuzz/corpus/alloc_ops/97546b42b2f825dc2a9ccb33c19beaa6fa44191e differ diff --git a/fuzz/corpus/alloc_ops/9771f781c7b5b73892fd7c4dc6f29c269d43b32d b/fuzz/corpus/alloc_ops/9771f781c7b5b73892fd7c4dc6f29c269d43b32d new file mode 100644 index 0000000..3b8f20e Binary files /dev/null and b/fuzz/corpus/alloc_ops/9771f781c7b5b73892fd7c4dc6f29c269d43b32d differ diff --git a/fuzz/corpus/alloc_ops/97892ea4c49aab598468143699aa482d642b2e4e b/fuzz/corpus/alloc_ops/97892ea4c49aab598468143699aa482d642b2e4e new file mode 100644 index 0000000..07aa86c Binary files /dev/null and b/fuzz/corpus/alloc_ops/97892ea4c49aab598468143699aa482d642b2e4e differ diff --git a/fuzz/corpus/alloc_ops/97d891d7787cf171ca5dd09fb5b5eacd91636951 b/fuzz/corpus/alloc_ops/97d891d7787cf171ca5dd09fb5b5eacd91636951 new file mode 100644 index 0000000..35b080a Binary files /dev/null and b/fuzz/corpus/alloc_ops/97d891d7787cf171ca5dd09fb5b5eacd91636951 differ diff --git a/fuzz/corpus/alloc_ops/97e18835d51bb0f6ed2fcd6fcfe6e5d72c4e9ee1 b/fuzz/corpus/alloc_ops/97e18835d51bb0f6ed2fcd6fcfe6e5d72c4e9ee1 new file mode 100644 index 0000000..0b07acd Binary files /dev/null and b/fuzz/corpus/alloc_ops/97e18835d51bb0f6ed2fcd6fcfe6e5d72c4e9ee1 differ diff --git a/fuzz/corpus/alloc_ops/97e77f7377e0b8b111f3fbaf4ad196acd2f41d6e b/fuzz/corpus/alloc_ops/97e77f7377e0b8b111f3fbaf4ad196acd2f41d6e new file mode 100644 index 0000000..2f3299f Binary files /dev/null and b/fuzz/corpus/alloc_ops/97e77f7377e0b8b111f3fbaf4ad196acd2f41d6e differ diff --git a/fuzz/corpus/alloc_ops/983e6f5629964bc6e95ea9ed2b0f3c3c04008e64 b/fuzz/corpus/alloc_ops/983e6f5629964bc6e95ea9ed2b0f3c3c04008e64 new file mode 100644 index 0000000..0754457 Binary files /dev/null and b/fuzz/corpus/alloc_ops/983e6f5629964bc6e95ea9ed2b0f3c3c04008e64 differ diff --git a/fuzz/corpus/alloc_ops/986adec6e29f8e1fd2631017d3dd5dcb58800c05 b/fuzz/corpus/alloc_ops/986adec6e29f8e1fd2631017d3dd5dcb58800c05 new file mode 100644 index 0000000..39cfecd Binary files /dev/null and b/fuzz/corpus/alloc_ops/986adec6e29f8e1fd2631017d3dd5dcb58800c05 differ diff --git a/fuzz/corpus/alloc_ops/99055f8bb74a7d89c7f735e90687ae0b28e25326 b/fuzz/corpus/alloc_ops/99055f8bb74a7d89c7f735e90687ae0b28e25326 new file mode 100644 index 0000000..0aea4d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/99055f8bb74a7d89c7f735e90687ae0b28e25326 differ diff --git a/fuzz/corpus/alloc_ops/991170864ac600325afad4c9bac387395d4d2c76 b/fuzz/corpus/alloc_ops/991170864ac600325afad4c9bac387395d4d2c76 new file mode 100644 index 0000000..a1656c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/991170864ac600325afad4c9bac387395d4d2c76 differ diff --git a/fuzz/corpus/alloc_ops/9920913db477755b0445a781505ac9ac2de590ed b/fuzz/corpus/alloc_ops/9920913db477755b0445a781505ac9ac2de590ed new file mode 100644 index 0000000..55a8632 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9920913db477755b0445a781505ac9ac2de590ed differ diff --git a/fuzz/corpus/alloc_ops/994980d17fc27ea396f42ee86b3565c3150968d6 b/fuzz/corpus/alloc_ops/994980d17fc27ea396f42ee86b3565c3150968d6 new file mode 100644 index 0000000..04aca45 Binary files /dev/null and b/fuzz/corpus/alloc_ops/994980d17fc27ea396f42ee86b3565c3150968d6 differ diff --git a/fuzz/corpus/alloc_ops/9955678483c8f0d6f11101ed6d23d61b74254da9 b/fuzz/corpus/alloc_ops/9955678483c8f0d6f11101ed6d23d61b74254da9 new file mode 100644 index 0000000..364b764 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9955678483c8f0d6f11101ed6d23d61b74254da9 differ diff --git a/fuzz/corpus/alloc_ops/999a0a8cad102eb519ca788d6e0cd48ee9e6ca3e b/fuzz/corpus/alloc_ops/999a0a8cad102eb519ca788d6e0cd48ee9e6ca3e new file mode 100644 index 0000000..8f74629 --- /dev/null +++ b/fuzz/corpus/alloc_ops/999a0a8cad102eb519ca788d6e0cd48ee9e6ca3e @@ -0,0 +1 @@ +„ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/99ae4a5b0fc7ced1f81a460b548e4a46bf244a29 b/fuzz/corpus/alloc_ops/99ae4a5b0fc7ced1f81a460b548e4a46bf244a29 new file mode 100644 index 0000000..32cf2c0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/99ae4a5b0fc7ced1f81a460b548e4a46bf244a29 differ diff --git a/fuzz/corpus/alloc_ops/99eefb8ba89399adb017c4315c484a4c2f739420 b/fuzz/corpus/alloc_ops/99eefb8ba89399adb017c4315c484a4c2f739420 new file mode 100644 index 0000000..01b1b1c Binary files /dev/null and b/fuzz/corpus/alloc_ops/99eefb8ba89399adb017c4315c484a4c2f739420 differ diff --git a/fuzz/corpus/alloc_ops/9a14986f55ee27fc2aba9efa09e42a47ea4ee22f b/fuzz/corpus/alloc_ops/9a14986f55ee27fc2aba9efa09e42a47ea4ee22f new file mode 100644 index 0000000..ac43644 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9a14986f55ee27fc2aba9efa09e42a47ea4ee22f differ diff --git a/fuzz/corpus/alloc_ops/9a6fcc84819475bd5769a8a4bc26d9648072a2c8 b/fuzz/corpus/alloc_ops/9a6fcc84819475bd5769a8a4bc26d9648072a2c8 new file mode 100644 index 0000000..3fe1b8f Binary files /dev/null and b/fuzz/corpus/alloc_ops/9a6fcc84819475bd5769a8a4bc26d9648072a2c8 differ diff --git a/fuzz/corpus/alloc_ops/9a892560e66cedec56ddd8875584697f39b76da3 b/fuzz/corpus/alloc_ops/9a892560e66cedec56ddd8875584697f39b76da3 new file mode 100644 index 0000000..2db3c35 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9a892560e66cedec56ddd8875584697f39b76da3 differ diff --git a/fuzz/corpus/alloc_ops/9ac5bf1de09efea8372c1b1e3d10092714152949 b/fuzz/corpus/alloc_ops/9ac5bf1de09efea8372c1b1e3d10092714152949 new file mode 100644 index 0000000..0f268cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/9ac5bf1de09efea8372c1b1e3d10092714152949 differ diff --git a/fuzz/corpus/alloc_ops/9ad8b4b0356dfd238afa6ef92d570556daabd9f7 b/fuzz/corpus/alloc_ops/9ad8b4b0356dfd238afa6ef92d570556daabd9f7 new file mode 100644 index 0000000..bf8461b Binary files /dev/null and b/fuzz/corpus/alloc_ops/9ad8b4b0356dfd238afa6ef92d570556daabd9f7 differ diff --git a/fuzz/corpus/alloc_ops/9afa4c2b150375d8e997424657bf0f81d14d8a97 b/fuzz/corpus/alloc_ops/9afa4c2b150375d8e997424657bf0f81d14d8a97 new file mode 100644 index 0000000..d686ed4 --- /dev/null +++ b/fuzz/corpus/alloc_ops/9afa4c2b150375d8e997424657bf0f81d14d8a97 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/9b2c5511f4d87c943d94d2312709e5d92fdbfcab b/fuzz/corpus/alloc_ops/9b2c5511f4d87c943d94d2312709e5d92fdbfcab new file mode 100644 index 0000000..a6cfaaf Binary files /dev/null and b/fuzz/corpus/alloc_ops/9b2c5511f4d87c943d94d2312709e5d92fdbfcab differ diff --git a/fuzz/corpus/alloc_ops/9b7215ff4a429aba618f53cfde5b430ec9c7ee05 b/fuzz/corpus/alloc_ops/9b7215ff4a429aba618f53cfde5b430ec9c7ee05 new file mode 100644 index 0000000..308a229 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9b7215ff4a429aba618f53cfde5b430ec9c7ee05 differ diff --git a/fuzz/corpus/alloc_ops/9b8add1b3135b78104bfd82b4fbc93be48d71f36 b/fuzz/corpus/alloc_ops/9b8add1b3135b78104bfd82b4fbc93be48d71f36 new file mode 100644 index 0000000..258ca28 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9b8add1b3135b78104bfd82b4fbc93be48d71f36 differ diff --git a/fuzz/corpus/alloc_ops/9bd8628bd7f9a3c8dc423d1fac7c74a8176aa55f b/fuzz/corpus/alloc_ops/9bd8628bd7f9a3c8dc423d1fac7c74a8176aa55f new file mode 100644 index 0000000..ead29e0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9bd8628bd7f9a3c8dc423d1fac7c74a8176aa55f differ diff --git a/fuzz/corpus/alloc_ops/9c0c9c05b3debf33b6de451048406985d5b8682d b/fuzz/corpus/alloc_ops/9c0c9c05b3debf33b6de451048406985d5b8682d new file mode 100644 index 0000000..c51aeee --- /dev/null +++ b/fuzz/corpus/alloc_ops/9c0c9c05b3debf33b6de451048406985d5b8682d @@ -0,0 +1 @@ +þþþþþþþþþþþþþþþþþþþþþþþþþþþ;þþþþþþþþþþþþþþþþþþþþþþþ¤þþþþþþþþþÿÿþþ;þþþþþþþKþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/9c3dee6da562228de5807d87347a52e3b0911747 b/fuzz/corpus/alloc_ops/9c3dee6da562228de5807d87347a52e3b0911747 new file mode 100644 index 0000000..9f94734 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9c3dee6da562228de5807d87347a52e3b0911747 differ diff --git a/fuzz/corpus/alloc_ops/9c51ba20e9dcdeda63aaed5edb2ae20a55ad92f9 b/fuzz/corpus/alloc_ops/9c51ba20e9dcdeda63aaed5edb2ae20a55ad92f9 new file mode 100644 index 0000000..efed0ad Binary files /dev/null and b/fuzz/corpus/alloc_ops/9c51ba20e9dcdeda63aaed5edb2ae20a55ad92f9 differ diff --git a/fuzz/corpus/alloc_ops/9cb607a4bb218ed837f613e7cf2736f65fe55faf b/fuzz/corpus/alloc_ops/9cb607a4bb218ed837f613e7cf2736f65fe55faf new file mode 100644 index 0000000..3ed95f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9cb607a4bb218ed837f613e7cf2736f65fe55faf differ diff --git a/fuzz/corpus/alloc_ops/9cdbf0c96ef15144ab148e5bc0840eab154d6f0f b/fuzz/corpus/alloc_ops/9cdbf0c96ef15144ab148e5bc0840eab154d6f0f new file mode 100644 index 0000000..a263e59 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9cdbf0c96ef15144ab148e5bc0840eab154d6f0f differ diff --git a/fuzz/corpus/alloc_ops/9db969cc168b2abdb88f8905aeed112ae5a4d9d3 b/fuzz/corpus/alloc_ops/9db969cc168b2abdb88f8905aeed112ae5a4d9d3 new file mode 100644 index 0000000..75fc913 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9db969cc168b2abdb88f8905aeed112ae5a4d9d3 differ diff --git a/fuzz/corpus/alloc_ops/9dcb5f6748aaebf8d34e16b8d1e42bbf37b9c454 b/fuzz/corpus/alloc_ops/9dcb5f6748aaebf8d34e16b8d1e42bbf37b9c454 new file mode 100644 index 0000000..c375aea Binary files /dev/null and b/fuzz/corpus/alloc_ops/9dcb5f6748aaebf8d34e16b8d1e42bbf37b9c454 differ diff --git a/fuzz/corpus/alloc_ops/9e7704b2331d089dcec10957ae1ed201edca0fba b/fuzz/corpus/alloc_ops/9e7704b2331d089dcec10957ae1ed201edca0fba new file mode 100644 index 0000000..08e53ce Binary files /dev/null and b/fuzz/corpus/alloc_ops/9e7704b2331d089dcec10957ae1ed201edca0fba differ diff --git a/fuzz/corpus/alloc_ops/9e941bf875378438a0c1cf6daa283a3164a78001 b/fuzz/corpus/alloc_ops/9e941bf875378438a0c1cf6daa283a3164a78001 new file mode 100644 index 0000000..7c66b00 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9e941bf875378438a0c1cf6daa283a3164a78001 differ diff --git a/fuzz/corpus/alloc_ops/9ecc4f5f79f4dc5f87a77c3b7e08326c8f8d191a b/fuzz/corpus/alloc_ops/9ecc4f5f79f4dc5f87a77c3b7e08326c8f8d191a new file mode 100644 index 0000000..7e90b51 Binary files /dev/null and b/fuzz/corpus/alloc_ops/9ecc4f5f79f4dc5f87a77c3b7e08326c8f8d191a differ diff --git a/fuzz/corpus/alloc_ops/9eef2ee95954f32af49ba94257abfca1d81cad3b b/fuzz/corpus/alloc_ops/9eef2ee95954f32af49ba94257abfca1d81cad3b new file mode 100644 index 0000000..22bd49f Binary files /dev/null and b/fuzz/corpus/alloc_ops/9eef2ee95954f32af49ba94257abfca1d81cad3b differ diff --git a/fuzz/corpus/alloc_ops/9f4c7f8dc78a5fb02cdc9d8451bf74bab8c2cf6b b/fuzz/corpus/alloc_ops/9f4c7f8dc78a5fb02cdc9d8451bf74bab8c2cf6b new file mode 100644 index 0000000..f29bf3b Binary files /dev/null and b/fuzz/corpus/alloc_ops/9f4c7f8dc78a5fb02cdc9d8451bf74bab8c2cf6b differ diff --git a/fuzz/corpus/alloc_ops/9fa719ad995a1275d0d5d3bef32d3b776bfa4356 b/fuzz/corpus/alloc_ops/9fa719ad995a1275d0d5d3bef32d3b776bfa4356 new file mode 100644 index 0000000..7ff2daa Binary files /dev/null and b/fuzz/corpus/alloc_ops/9fa719ad995a1275d0d5d3bef32d3b776bfa4356 differ diff --git a/fuzz/corpus/alloc_ops/9fff4ee681f8c00b0c0b2e2dfe957499b45f757f b/fuzz/corpus/alloc_ops/9fff4ee681f8c00b0c0b2e2dfe957499b45f757f new file mode 100644 index 0000000..36d693b Binary files /dev/null and b/fuzz/corpus/alloc_ops/9fff4ee681f8c00b0c0b2e2dfe957499b45f757f differ diff --git a/fuzz/corpus/alloc_ops/a05b27528f452eea450023dd5385ed6ab0db9f03 b/fuzz/corpus/alloc_ops/a05b27528f452eea450023dd5385ed6ab0db9f03 new file mode 100644 index 0000000..f394dee Binary files /dev/null and b/fuzz/corpus/alloc_ops/a05b27528f452eea450023dd5385ed6ab0db9f03 differ diff --git a/fuzz/corpus/alloc_ops/a0d41782463a8d19245e43a8c0838b1a36aa19d8 b/fuzz/corpus/alloc_ops/a0d41782463a8d19245e43a8c0838b1a36aa19d8 new file mode 100644 index 0000000..8276057 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a0d41782463a8d19245e43a8c0838b1a36aa19d8 differ diff --git a/fuzz/corpus/alloc_ops/a0f640fa361463a349883c33f3b2d5cf97071a78 b/fuzz/corpus/alloc_ops/a0f640fa361463a349883c33f3b2d5cf97071a78 new file mode 100644 index 0000000..8579fe8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a0f640fa361463a349883c33f3b2d5cf97071a78 differ diff --git a/fuzz/corpus/alloc_ops/a0f9bb5c87d197f304f2ec70a39b396c592fc91a b/fuzz/corpus/alloc_ops/a0f9bb5c87d197f304f2ec70a39b396c592fc91a new file mode 100644 index 0000000..7ce74fe Binary files /dev/null and b/fuzz/corpus/alloc_ops/a0f9bb5c87d197f304f2ec70a39b396c592fc91a differ diff --git a/fuzz/corpus/alloc_ops/a0fa7e4b531e5d6d45e981627cb84088ca769557 b/fuzz/corpus/alloc_ops/a0fa7e4b531e5d6d45e981627cb84088ca769557 new file mode 100644 index 0000000..468444f Binary files /dev/null and b/fuzz/corpus/alloc_ops/a0fa7e4b531e5d6d45e981627cb84088ca769557 differ diff --git a/fuzz/corpus/alloc_ops/a10b144d13e547f7372169a182ae4ae75411ebf0 b/fuzz/corpus/alloc_ops/a10b144d13e547f7372169a182ae4ae75411ebf0 new file mode 100644 index 0000000..d6100e0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a10b144d13e547f7372169a182ae4ae75411ebf0 differ diff --git a/fuzz/corpus/alloc_ops/a112a84a217b6658f8315988c6780ab864572d18 b/fuzz/corpus/alloc_ops/a112a84a217b6658f8315988c6780ab864572d18 new file mode 100644 index 0000000..c283dde Binary files /dev/null and b/fuzz/corpus/alloc_ops/a112a84a217b6658f8315988c6780ab864572d18 differ diff --git a/fuzz/corpus/alloc_ops/a1211fb979d9a41ca33b531678ef7fb475e7c2b4 b/fuzz/corpus/alloc_ops/a1211fb979d9a41ca33b531678ef7fb475e7c2b4 new file mode 100644 index 0000000..a430712 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a1211fb979d9a41ca33b531678ef7fb475e7c2b4 differ diff --git a/fuzz/corpus/alloc_ops/a12fda20ea4b29dd5996e533495e04fea53c9c20 b/fuzz/corpus/alloc_ops/a12fda20ea4b29dd5996e533495e04fea53c9c20 new file mode 100644 index 0000000..d16b16e Binary files /dev/null and b/fuzz/corpus/alloc_ops/a12fda20ea4b29dd5996e533495e04fea53c9c20 differ diff --git a/fuzz/corpus/alloc_ops/a168030c0157f812b93235e80b3082cb116ba9c9 b/fuzz/corpus/alloc_ops/a168030c0157f812b93235e80b3082cb116ba9c9 new file mode 100644 index 0000000..4de773d Binary files /dev/null and b/fuzz/corpus/alloc_ops/a168030c0157f812b93235e80b3082cb116ba9c9 differ diff --git a/fuzz/corpus/alloc_ops/a1ea80429b0a34b85108aa49af4be029810437eb b/fuzz/corpus/alloc_ops/a1ea80429b0a34b85108aa49af4be029810437eb new file mode 100644 index 0000000..6c0a70e Binary files /dev/null and b/fuzz/corpus/alloc_ops/a1ea80429b0a34b85108aa49af4be029810437eb differ diff --git a/fuzz/corpus/alloc_ops/a1fb776d78c2d1552c4ac4402b624cc6b5a0a0bb b/fuzz/corpus/alloc_ops/a1fb776d78c2d1552c4ac4402b624cc6b5a0a0bb new file mode 100644 index 0000000..b6a08f1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a1fb776d78c2d1552c4ac4402b624cc6b5a0a0bb differ diff --git a/fuzz/corpus/alloc_ops/a228391889bc1864921d30216017a93bed264f97 b/fuzz/corpus/alloc_ops/a228391889bc1864921d30216017a93bed264f97 new file mode 100644 index 0000000..31929af --- /dev/null +++ b/fuzz/corpus/alloc_ops/a228391889bc1864921d30216017a93bed264f97 @@ -0,0 +1 @@ +ÿýà \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/a22ebb5e25b91ce6cdd292c96f3214837bf7eb25 b/fuzz/corpus/alloc_ops/a22ebb5e25b91ce6cdd292c96f3214837bf7eb25 new file mode 100644 index 0000000..a9416b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a22ebb5e25b91ce6cdd292c96f3214837bf7eb25 differ diff --git a/fuzz/corpus/alloc_ops/a24935c163bcf29c35c476bf2a2c1ee19e2d8046 b/fuzz/corpus/alloc_ops/a24935c163bcf29c35c476bf2a2c1ee19e2d8046 new file mode 100644 index 0000000..d75d767 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a24935c163bcf29c35c476bf2a2c1ee19e2d8046 differ diff --git a/fuzz/corpus/alloc_ops/a29d8b655f330ffebd38840dfa771e76583ab105 b/fuzz/corpus/alloc_ops/a29d8b655f330ffebd38840dfa771e76583ab105 new file mode 100644 index 0000000..9b7f866 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a29d8b655f330ffebd38840dfa771e76583ab105 differ diff --git a/fuzz/corpus/alloc_ops/a29ebdae1b12a0258a5d530d68a9a85d6a7bbce7 b/fuzz/corpus/alloc_ops/a29ebdae1b12a0258a5d530d68a9a85d6a7bbce7 new file mode 100644 index 0000000..06d899b Binary files /dev/null and b/fuzz/corpus/alloc_ops/a29ebdae1b12a0258a5d530d68a9a85d6a7bbce7 differ diff --git a/fuzz/corpus/alloc_ops/a2c48f6f4f9050a68b0cb81fb999e775d4c5b673 b/fuzz/corpus/alloc_ops/a2c48f6f4f9050a68b0cb81fb999e775d4c5b673 new file mode 100644 index 0000000..b0abe8b Binary files /dev/null and b/fuzz/corpus/alloc_ops/a2c48f6f4f9050a68b0cb81fb999e775d4c5b673 differ diff --git a/fuzz/corpus/alloc_ops/a309ade3af9d3fbee3c2c55815b9ea863e54e3dc b/fuzz/corpus/alloc_ops/a309ade3af9d3fbee3c2c55815b9ea863e54e3dc new file mode 100644 index 0000000..31628c4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a309ade3af9d3fbee3c2c55815b9ea863e54e3dc differ diff --git a/fuzz/corpus/alloc_ops/a3190c88cf2646cbe46c12130132a47d88435a2e b/fuzz/corpus/alloc_ops/a3190c88cf2646cbe46c12130132a47d88435a2e new file mode 100644 index 0000000..bed7438 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3190c88cf2646cbe46c12130132a47d88435a2e differ diff --git a/fuzz/corpus/alloc_ops/a3232826d105ae167173d56e4aad84198ee338bc b/fuzz/corpus/alloc_ops/a3232826d105ae167173d56e4aad84198ee338bc new file mode 100644 index 0000000..97ac47b Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3232826d105ae167173d56e4aad84198ee338bc differ diff --git a/fuzz/corpus/alloc_ops/a333c2175bc9785e32def3b9bd7f34129df6e1ee b/fuzz/corpus/alloc_ops/a333c2175bc9785e32def3b9bd7f34129df6e1ee new file mode 100644 index 0000000..bcfc122 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a333c2175bc9785e32def3b9bd7f34129df6e1ee differ diff --git a/fuzz/corpus/alloc_ops/a36974e030447148069a5f156d0c47d0966d2edd b/fuzz/corpus/alloc_ops/a36974e030447148069a5f156d0c47d0966d2edd new file mode 100644 index 0000000..100c5af Binary files /dev/null and b/fuzz/corpus/alloc_ops/a36974e030447148069a5f156d0c47d0966d2edd differ diff --git a/fuzz/corpus/alloc_ops/a3793aed3bdb47670e5b7a26584aaae46786ed8d b/fuzz/corpus/alloc_ops/a3793aed3bdb47670e5b7a26584aaae46786ed8d new file mode 100644 index 0000000..11e1dbb Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3793aed3bdb47670e5b7a26584aaae46786ed8d differ diff --git a/fuzz/corpus/alloc_ops/a3a1d1e6dac23d81f30e6a80fddd874883a712ce b/fuzz/corpus/alloc_ops/a3a1d1e6dac23d81f30e6a80fddd874883a712ce new file mode 100644 index 0000000..e56b6d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3a1d1e6dac23d81f30e6a80fddd874883a712ce differ diff --git a/fuzz/corpus/alloc_ops/a3aee8ec5c803790680841b10ba304b9cd3ebaf0 b/fuzz/corpus/alloc_ops/a3aee8ec5c803790680841b10ba304b9cd3ebaf0 new file mode 100644 index 0000000..c4a58b9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3aee8ec5c803790680841b10ba304b9cd3ebaf0 differ diff --git a/fuzz/corpus/alloc_ops/a3c55188ad6fe16bb6cdf014af5858652ebb2f5c b/fuzz/corpus/alloc_ops/a3c55188ad6fe16bb6cdf014af5858652ebb2f5c new file mode 100644 index 0000000..55a4940 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3c55188ad6fe16bb6cdf014af5858652ebb2f5c differ diff --git a/fuzz/corpus/alloc_ops/a3dc5f6fa01ed40d316ba7c57f2e4f2a722494c2 b/fuzz/corpus/alloc_ops/a3dc5f6fa01ed40d316ba7c57f2e4f2a722494c2 new file mode 100644 index 0000000..0fd271e --- /dev/null +++ b/fuzz/corpus/alloc_ops/a3dc5f6fa01ed40d316ba7c57f2e4f2a722494c2 @@ -0,0 +1 @@ +ªPPªªŠªªªªª \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/a3e398f01088099005f8097866dd5f6afde30038 b/fuzz/corpus/alloc_ops/a3e398f01088099005f8097866dd5f6afde30038 new file mode 100644 index 0000000..97d512a Binary files /dev/null and b/fuzz/corpus/alloc_ops/a3e398f01088099005f8097866dd5f6afde30038 differ diff --git a/fuzz/corpus/alloc_ops/a45282f9d48cbb53e325a7c3cfb8f99f43b9745e b/fuzz/corpus/alloc_ops/a45282f9d48cbb53e325a7c3cfb8f99f43b9745e new file mode 100644 index 0000000..f0e325a Binary files /dev/null and b/fuzz/corpus/alloc_ops/a45282f9d48cbb53e325a7c3cfb8f99f43b9745e differ diff --git a/fuzz/corpus/alloc_ops/a455c44adc3cbec1317627a923c72252b820df4d b/fuzz/corpus/alloc_ops/a455c44adc3cbec1317627a923c72252b820df4d new file mode 100644 index 0000000..0fdd464 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a455c44adc3cbec1317627a923c72252b820df4d differ diff --git a/fuzz/corpus/alloc_ops/a47c8bb654cecf164a66934cf6a635688ca82f29 b/fuzz/corpus/alloc_ops/a47c8bb654cecf164a66934cf6a635688ca82f29 new file mode 100644 index 0000000..0bb9412 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a47c8bb654cecf164a66934cf6a635688ca82f29 differ diff --git a/fuzz/corpus/alloc_ops/a4845709406080f95ea2dc1032ad815bd64a808e b/fuzz/corpus/alloc_ops/a4845709406080f95ea2dc1032ad815bd64a808e new file mode 100644 index 0000000..aa02523 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a4845709406080f95ea2dc1032ad815bd64a808e differ diff --git a/fuzz/corpus/alloc_ops/a489c9d3cec66fc49b333635d570271fa9f4fd96 b/fuzz/corpus/alloc_ops/a489c9d3cec66fc49b333635d570271fa9f4fd96 new file mode 100644 index 0000000..1872f74 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a489c9d3cec66fc49b333635d570271fa9f4fd96 differ diff --git a/fuzz/corpus/alloc_ops/a4929fd94bc8c93b3998b49db7df3b8538795deb b/fuzz/corpus/alloc_ops/a4929fd94bc8c93b3998b49db7df3b8538795deb new file mode 100644 index 0000000..f9320ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/a4929fd94bc8c93b3998b49db7df3b8538795deb differ diff --git a/fuzz/corpus/alloc_ops/a49f40180973dafd823c43c98ff49397b867d9cc b/fuzz/corpus/alloc_ops/a49f40180973dafd823c43c98ff49397b867d9cc new file mode 100644 index 0000000..7951001 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a49f40180973dafd823c43c98ff49397b867d9cc differ diff --git a/fuzz/corpus/alloc_ops/a4b16e2b347c262aeb66b018df7822ad42864f44 b/fuzz/corpus/alloc_ops/a4b16e2b347c262aeb66b018df7822ad42864f44 new file mode 100644 index 0000000..4ad6b6f Binary files /dev/null and b/fuzz/corpus/alloc_ops/a4b16e2b347c262aeb66b018df7822ad42864f44 differ diff --git a/fuzz/corpus/alloc_ops/a4b1a102f172d835d506f1652c736f4d6ecfaa16 b/fuzz/corpus/alloc_ops/a4b1a102f172d835d506f1652c736f4d6ecfaa16 new file mode 100644 index 0000000..9690f84 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a4b1a102f172d835d506f1652c736f4d6ecfaa16 differ diff --git a/fuzz/corpus/alloc_ops/a4c70736ea4bbfa12c7974fbea9f6d207a61bb8f b/fuzz/corpus/alloc_ops/a4c70736ea4bbfa12c7974fbea9f6d207a61bb8f new file mode 100644 index 0000000..993f895 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a4c70736ea4bbfa12c7974fbea9f6d207a61bb8f differ diff --git a/fuzz/corpus/alloc_ops/a5343d6b94997b5a772bb43defc37b4b1670fbba b/fuzz/corpus/alloc_ops/a5343d6b94997b5a772bb43defc37b4b1670fbba new file mode 100644 index 0000000..fa53f33 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a5343d6b94997b5a772bb43defc37b4b1670fbba differ diff --git a/fuzz/corpus/alloc_ops/a581b3e75f0453d24103780982f295b00e65bf85 b/fuzz/corpus/alloc_ops/a581b3e75f0453d24103780982f295b00e65bf85 new file mode 100644 index 0000000..070ad9f Binary files /dev/null and b/fuzz/corpus/alloc_ops/a581b3e75f0453d24103780982f295b00e65bf85 differ diff --git a/fuzz/corpus/alloc_ops/a650f3cda3b7b659f4f4bcf2ff8169feb3dfb314 b/fuzz/corpus/alloc_ops/a650f3cda3b7b659f4f4bcf2ff8169feb3dfb314 new file mode 100644 index 0000000..a78f171 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a650f3cda3b7b659f4f4bcf2ff8169feb3dfb314 differ diff --git a/fuzz/corpus/alloc_ops/a668b0029455655ff657449cc4e8c4762144d338 b/fuzz/corpus/alloc_ops/a668b0029455655ff657449cc4e8c4762144d338 new file mode 100644 index 0000000..68a0f4e Binary files /dev/null and b/fuzz/corpus/alloc_ops/a668b0029455655ff657449cc4e8c4762144d338 differ diff --git a/fuzz/corpus/alloc_ops/a682f10734f9b552b9b7aac60cf97ef2f9bf5dd7 b/fuzz/corpus/alloc_ops/a682f10734f9b552b9b7aac60cf97ef2f9bf5dd7 new file mode 100644 index 0000000..fae8b92 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a682f10734f9b552b9b7aac60cf97ef2f9bf5dd7 differ diff --git a/fuzz/corpus/alloc_ops/a686e59dd37f190758090d39940df6845d3fd70b b/fuzz/corpus/alloc_ops/a686e59dd37f190758090d39940df6845d3fd70b new file mode 100644 index 0000000..367ad55 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a686e59dd37f190758090d39940df6845d3fd70b differ diff --git a/fuzz/corpus/alloc_ops/a6909ab9d65fb6b3cc77597f8ac729e18d779134 b/fuzz/corpus/alloc_ops/a6909ab9d65fb6b3cc77597f8ac729e18d779134 new file mode 100644 index 0000000..fb91f78 --- /dev/null +++ b/fuzz/corpus/alloc_ops/a6909ab9d65fb6b3cc77597f8ac729e18d779134 @@ -0,0 +1 @@ +ö­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­a­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/a6984ff8b72056d50fab33c45ab23c77425a3ab6 b/fuzz/corpus/alloc_ops/a6984ff8b72056d50fab33c45ab23c77425a3ab6 new file mode 100644 index 0000000..49d5a4e Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6984ff8b72056d50fab33c45ab23c77425a3ab6 differ diff --git a/fuzz/corpus/alloc_ops/a6a0be65da34182698bc5b80717fae749edd610f b/fuzz/corpus/alloc_ops/a6a0be65da34182698bc5b80717fae749edd610f new file mode 100644 index 0000000..6c927d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6a0be65da34182698bc5b80717fae749edd610f differ diff --git a/fuzz/corpus/alloc_ops/a6a44230ca9112e71cf87915a7af34842badc1d7 b/fuzz/corpus/alloc_ops/a6a44230ca9112e71cf87915a7af34842badc1d7 new file mode 100644 index 0000000..8db892c --- /dev/null +++ b/fuzz/corpus/alloc_ops/a6a44230ca9112e71cf87915a7af34842badc1d7 @@ -0,0 +1 @@ +ÿýà \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/a6bcfe7a84a284a55d7b464a860f12f926b4804d b/fuzz/corpus/alloc_ops/a6bcfe7a84a284a55d7b464a860f12f926b4804d new file mode 100644 index 0000000..7240dd5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6bcfe7a84a284a55d7b464a860f12f926b4804d differ diff --git a/fuzz/corpus/alloc_ops/a6c342b6f7a94248bec750d2d15b1b4177e26030 b/fuzz/corpus/alloc_ops/a6c342b6f7a94248bec750d2d15b1b4177e26030 new file mode 100644 index 0000000..ac23ac2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6c342b6f7a94248bec750d2d15b1b4177e26030 differ diff --git a/fuzz/corpus/alloc_ops/a6cd71e8f9f782897bb0fa350c2bf3b838bf4d78 b/fuzz/corpus/alloc_ops/a6cd71e8f9f782897bb0fa350c2bf3b838bf4d78 new file mode 100644 index 0000000..1305f48 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6cd71e8f9f782897bb0fa350c2bf3b838bf4d78 differ diff --git a/fuzz/corpus/alloc_ops/a6e2bf65913f53ec69dacacc37a0a84993403243 b/fuzz/corpus/alloc_ops/a6e2bf65913f53ec69dacacc37a0a84993403243 new file mode 100644 index 0000000..55b8119 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a6e2bf65913f53ec69dacacc37a0a84993403243 differ diff --git a/fuzz/corpus/alloc_ops/a734a5f80c888a562db583cf64f35d40a54f8119 b/fuzz/corpus/alloc_ops/a734a5f80c888a562db583cf64f35d40a54f8119 new file mode 100644 index 0000000..5a2f5a6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a734a5f80c888a562db583cf64f35d40a54f8119 differ diff --git a/fuzz/corpus/alloc_ops/a77984307779a9eb9a9525ecb187c1ecd7b450a9 b/fuzz/corpus/alloc_ops/a77984307779a9eb9a9525ecb187c1ecd7b450a9 new file mode 100644 index 0000000..55dc805 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a77984307779a9eb9a9525ecb187c1ecd7b450a9 differ diff --git a/fuzz/corpus/alloc_ops/a7a5914afbd0c9a7748a83f58eb72f0f520f1e11 b/fuzz/corpus/alloc_ops/a7a5914afbd0c9a7748a83f58eb72f0f520f1e11 new file mode 100644 index 0000000..f23d811 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a7a5914afbd0c9a7748a83f58eb72f0f520f1e11 differ diff --git a/fuzz/corpus/alloc_ops/a7d51ea12b2c8f97bd2235510abf25749bd27c03 b/fuzz/corpus/alloc_ops/a7d51ea12b2c8f97bd2235510abf25749bd27c03 new file mode 100644 index 0000000..c1092a4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a7d51ea12b2c8f97bd2235510abf25749bd27c03 differ diff --git a/fuzz/corpus/alloc_ops/a800ce92faa58af03848d1d80ccc2e35bbe15108 b/fuzz/corpus/alloc_ops/a800ce92faa58af03848d1d80ccc2e35bbe15108 new file mode 100644 index 0000000..7009fea Binary files /dev/null and b/fuzz/corpus/alloc_ops/a800ce92faa58af03848d1d80ccc2e35bbe15108 differ diff --git a/fuzz/corpus/alloc_ops/a823b4e640f7b27e077bedf126aee98b86328529 b/fuzz/corpus/alloc_ops/a823b4e640f7b27e077bedf126aee98b86328529 new file mode 100644 index 0000000..764d1e4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a823b4e640f7b27e077bedf126aee98b86328529 differ diff --git a/fuzz/corpus/alloc_ops/a8275f8dca4f10f550d17a4ca10c30c88e4d735c b/fuzz/corpus/alloc_ops/a8275f8dca4f10f550d17a4ca10c30c88e4d735c new file mode 100644 index 0000000..0789118 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a8275f8dca4f10f550d17a4ca10c30c88e4d735c differ diff --git a/fuzz/corpus/alloc_ops/a83c6d20d080deb3db72fddcf24492400f5c3863 b/fuzz/corpus/alloc_ops/a83c6d20d080deb3db72fddcf24492400f5c3863 new file mode 100644 index 0000000..549eb6c Binary files /dev/null and b/fuzz/corpus/alloc_ops/a83c6d20d080deb3db72fddcf24492400f5c3863 differ diff --git a/fuzz/corpus/alloc_ops/a848af9cc9abcea71040c055aacbd41d350f3c39 b/fuzz/corpus/alloc_ops/a848af9cc9abcea71040c055aacbd41d350f3c39 new file mode 100644 index 0000000..8799e96 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a848af9cc9abcea71040c055aacbd41d350f3c39 differ diff --git a/fuzz/corpus/alloc_ops/a883378617e80968dfc62dd164d38641a1dc4d6a b/fuzz/corpus/alloc_ops/a883378617e80968dfc62dd164d38641a1dc4d6a new file mode 100644 index 0000000..b90ab2c Binary files /dev/null and b/fuzz/corpus/alloc_ops/a883378617e80968dfc62dd164d38641a1dc4d6a differ diff --git a/fuzz/corpus/alloc_ops/a8e1210e06821ab1e1a4b770a0b42d7d9c316aab b/fuzz/corpus/alloc_ops/a8e1210e06821ab1e1a4b770a0b42d7d9c316aab new file mode 100644 index 0000000..12f4ba4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a8e1210e06821ab1e1a4b770a0b42d7d9c316aab differ diff --git a/fuzz/corpus/alloc_ops/a95c23455016598e6e00829562422e2291f6954b b/fuzz/corpus/alloc_ops/a95c23455016598e6e00829562422e2291f6954b new file mode 100644 index 0000000..ae21642 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a95c23455016598e6e00829562422e2291f6954b differ diff --git a/fuzz/corpus/alloc_ops/a98981fa00ce069f92c70007d90307c6303a0141 b/fuzz/corpus/alloc_ops/a98981fa00ce069f92c70007d90307c6303a0141 new file mode 100644 index 0000000..e7a53bd Binary files /dev/null and b/fuzz/corpus/alloc_ops/a98981fa00ce069f92c70007d90307c6303a0141 differ diff --git a/fuzz/corpus/alloc_ops/a98d86610867d85d58e63ec1726e5205c7bdab83 b/fuzz/corpus/alloc_ops/a98d86610867d85d58e63ec1726e5205c7bdab83 new file mode 100644 index 0000000..baa1a71 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a98d86610867d85d58e63ec1726e5205c7bdab83 differ diff --git a/fuzz/corpus/alloc_ops/a999e0989bad3b54900e4bb76225b09245e8ac15 b/fuzz/corpus/alloc_ops/a999e0989bad3b54900e4bb76225b09245e8ac15 new file mode 100644 index 0000000..0c6fe92 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a999e0989bad3b54900e4bb76225b09245e8ac15 differ diff --git a/fuzz/corpus/alloc_ops/a9c15958232c3f659280bf558ac35a81df722d4e b/fuzz/corpus/alloc_ops/a9c15958232c3f659280bf558ac35a81df722d4e new file mode 100644 index 0000000..6c981a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/a9c15958232c3f659280bf558ac35a81df722d4e differ diff --git a/fuzz/corpus/alloc_ops/a9de501bd96364662356b29faee5662ed5d8a33e b/fuzz/corpus/alloc_ops/a9de501bd96364662356b29faee5662ed5d8a33e new file mode 100644 index 0000000..caad533 --- /dev/null +++ b/fuzz/corpus/alloc_ops/a9de501bd96364662356b29faee5662ed5d8a33e @@ -0,0 +1 @@ +† \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/a9ed61f145489d11d2489dd6301510927893d86a b/fuzz/corpus/alloc_ops/a9ed61f145489d11d2489dd6301510927893d86a new file mode 100644 index 0000000..584619a Binary files /dev/null and b/fuzz/corpus/alloc_ops/a9ed61f145489d11d2489dd6301510927893d86a differ diff --git a/fuzz/corpus/alloc_ops/aa5aac114d29cd3e4090f1743c9b6fa98c936195 b/fuzz/corpus/alloc_ops/aa5aac114d29cd3e4090f1743c9b6fa98c936195 new file mode 100644 index 0000000..e63cea1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/aa5aac114d29cd3e4090f1743c9b6fa98c936195 differ diff --git a/fuzz/corpus/alloc_ops/aa774efbfacde81f216731d3b5b62c75f40f5e50 b/fuzz/corpus/alloc_ops/aa774efbfacde81f216731d3b5b62c75f40f5e50 new file mode 100644 index 0000000..abe72bf Binary files /dev/null and b/fuzz/corpus/alloc_ops/aa774efbfacde81f216731d3b5b62c75f40f5e50 differ diff --git a/fuzz/corpus/alloc_ops/aa8cfdfb0196cddb3163c4b3e76ad6256dda56d3 b/fuzz/corpus/alloc_ops/aa8cfdfb0196cddb3163c4b3e76ad6256dda56d3 new file mode 100644 index 0000000..86c25b0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/aa8cfdfb0196cddb3163c4b3e76ad6256dda56d3 differ diff --git a/fuzz/corpus/alloc_ops/aa9f9ff1d93c637b5304e54041be805f397ebbcb b/fuzz/corpus/alloc_ops/aa9f9ff1d93c637b5304e54041be805f397ebbcb new file mode 100644 index 0000000..dc13914 Binary files /dev/null and b/fuzz/corpus/alloc_ops/aa9f9ff1d93c637b5304e54041be805f397ebbcb differ diff --git a/fuzz/corpus/alloc_ops/aaa89adf331468a9a2aab528c4f34f477e72803e b/fuzz/corpus/alloc_ops/aaa89adf331468a9a2aab528c4f34f477e72803e new file mode 100644 index 0000000..6e44e06 Binary files /dev/null and b/fuzz/corpus/alloc_ops/aaa89adf331468a9a2aab528c4f34f477e72803e differ diff --git a/fuzz/corpus/alloc_ops/aad5bd3a5753c222c08758a68227444b0d7a27d2 b/fuzz/corpus/alloc_ops/aad5bd3a5753c222c08758a68227444b0d7a27d2 new file mode 100644 index 0000000..b94ab2e Binary files /dev/null and b/fuzz/corpus/alloc_ops/aad5bd3a5753c222c08758a68227444b0d7a27d2 differ diff --git a/fuzz/corpus/alloc_ops/aafa96ae83bd55b588a779e57bdf742497c48fef b/fuzz/corpus/alloc_ops/aafa96ae83bd55b588a779e57bdf742497c48fef new file mode 100644 index 0000000..c7bfdfe Binary files /dev/null and b/fuzz/corpus/alloc_ops/aafa96ae83bd55b588a779e57bdf742497c48fef differ diff --git a/fuzz/corpus/alloc_ops/ab0b9f8b039f1c6d78a30c642ec4db6556bf8b76 b/fuzz/corpus/alloc_ops/ab0b9f8b039f1c6d78a30c642ec4db6556bf8b76 new file mode 100644 index 0000000..eb07179 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab0b9f8b039f1c6d78a30c642ec4db6556bf8b76 differ diff --git a/fuzz/corpus/alloc_ops/ab13fbe63b7452f85de0cd6fe56574d1f3205a7b b/fuzz/corpus/alloc_ops/ab13fbe63b7452f85de0cd6fe56574d1f3205a7b new file mode 100644 index 0000000..8e34882 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab13fbe63b7452f85de0cd6fe56574d1f3205a7b differ diff --git a/fuzz/corpus/alloc_ops/ab285f6e7ab214535ecee84f2aa689b0e597d6e7 b/fuzz/corpus/alloc_ops/ab285f6e7ab214535ecee84f2aa689b0e597d6e7 new file mode 100644 index 0000000..0356f7b Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab285f6e7ab214535ecee84f2aa689b0e597d6e7 differ diff --git a/fuzz/corpus/alloc_ops/ab559f6f182c68501cfe6f2459b804b6fcde2358 b/fuzz/corpus/alloc_ops/ab559f6f182c68501cfe6f2459b804b6fcde2358 new file mode 100644 index 0000000..8100e2f Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab559f6f182c68501cfe6f2459b804b6fcde2358 differ diff --git a/fuzz/corpus/alloc_ops/ab926ce489420971b53de1292d256f552b5057cc b/fuzz/corpus/alloc_ops/ab926ce489420971b53de1292d256f552b5057cc new file mode 100644 index 0000000..ed92f2a Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab926ce489420971b53de1292d256f552b5057cc differ diff --git a/fuzz/corpus/alloc_ops/ab9b8bfe199739b2cfb00d20319ef7ac0c0dc70f b/fuzz/corpus/alloc_ops/ab9b8bfe199739b2cfb00d20319ef7ac0c0dc70f new file mode 100644 index 0000000..2fd138e Binary files /dev/null and b/fuzz/corpus/alloc_ops/ab9b8bfe199739b2cfb00d20319ef7ac0c0dc70f differ diff --git a/fuzz/corpus/alloc_ops/abb13b4394813e732eac053cc1686dd7f38bb883 b/fuzz/corpus/alloc_ops/abb13b4394813e732eac053cc1686dd7f38bb883 new file mode 100644 index 0000000..0a69238 Binary files /dev/null and b/fuzz/corpus/alloc_ops/abb13b4394813e732eac053cc1686dd7f38bb883 differ diff --git a/fuzz/corpus/alloc_ops/abd9c4a2b175c6b26d5026b59c6ec21115b96a61 b/fuzz/corpus/alloc_ops/abd9c4a2b175c6b26d5026b59c6ec21115b96a61 new file mode 100644 index 0000000..6e4fd31 Binary files /dev/null and b/fuzz/corpus/alloc_ops/abd9c4a2b175c6b26d5026b59c6ec21115b96a61 differ diff --git a/fuzz/corpus/alloc_ops/abe860d0594479007e73b9c82e9dcb8442998c6b b/fuzz/corpus/alloc_ops/abe860d0594479007e73b9c82e9dcb8442998c6b new file mode 100644 index 0000000..51baac8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/abe860d0594479007e73b9c82e9dcb8442998c6b differ diff --git a/fuzz/corpus/alloc_ops/abf0f441dadd8f47febd92692b64f3dda487da10 b/fuzz/corpus/alloc_ops/abf0f441dadd8f47febd92692b64f3dda487da10 new file mode 100644 index 0000000..a4365dc Binary files /dev/null and b/fuzz/corpus/alloc_ops/abf0f441dadd8f47febd92692b64f3dda487da10 differ diff --git a/fuzz/corpus/alloc_ops/ac2f0780c5b41cacdf8bc660b2c42e3475a63401 b/fuzz/corpus/alloc_ops/ac2f0780c5b41cacdf8bc660b2c42e3475a63401 new file mode 100644 index 0000000..97e9aae Binary files /dev/null and b/fuzz/corpus/alloc_ops/ac2f0780c5b41cacdf8bc660b2c42e3475a63401 differ diff --git a/fuzz/corpus/alloc_ops/ac3a1f090a4b2e4f8996aad40b7c0f8c58e30003 b/fuzz/corpus/alloc_ops/ac3a1f090a4b2e4f8996aad40b7c0f8c58e30003 new file mode 100644 index 0000000..7d72b19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ac3a1f090a4b2e4f8996aad40b7c0f8c58e30003 differ diff --git a/fuzz/corpus/alloc_ops/ac988cb82703f0d7c4573a13ab5ea11c1b9f2c21 b/fuzz/corpus/alloc_ops/ac988cb82703f0d7c4573a13ab5ea11c1b9f2c21 new file mode 100644 index 0000000..9735f63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ac988cb82703f0d7c4573a13ab5ea11c1b9f2c21 differ diff --git a/fuzz/corpus/alloc_ops/aca7085ac086bf7fad3ea4be0957d50fac7f865a b/fuzz/corpus/alloc_ops/aca7085ac086bf7fad3ea4be0957d50fac7f865a new file mode 100644 index 0000000..84e9218 Binary files /dev/null and b/fuzz/corpus/alloc_ops/aca7085ac086bf7fad3ea4be0957d50fac7f865a differ diff --git a/fuzz/corpus/alloc_ops/acb3a646b45a2344aec1e167164e68ec2c4ff60d b/fuzz/corpus/alloc_ops/acb3a646b45a2344aec1e167164e68ec2c4ff60d new file mode 100644 index 0000000..8285b15 Binary files /dev/null and b/fuzz/corpus/alloc_ops/acb3a646b45a2344aec1e167164e68ec2c4ff60d differ diff --git a/fuzz/corpus/alloc_ops/ad4d587fc6fd0034566c155586c09699e1002783 b/fuzz/corpus/alloc_ops/ad4d587fc6fd0034566c155586c09699e1002783 new file mode 100644 index 0000000..274abf3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ad4d587fc6fd0034566c155586c09699e1002783 differ diff --git a/fuzz/corpus/alloc_ops/ad743c8d74bb3cbcd1c3b2e390c2d4bd3858ef1f b/fuzz/corpus/alloc_ops/ad743c8d74bb3cbcd1c3b2e390c2d4bd3858ef1f new file mode 100644 index 0000000..f182e14 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ad743c8d74bb3cbcd1c3b2e390c2d4bd3858ef1f differ diff --git a/fuzz/corpus/alloc_ops/ad7a7f8dd8618efaa22bf7553c8f01360731cf57 b/fuzz/corpus/alloc_ops/ad7a7f8dd8618efaa22bf7553c8f01360731cf57 new file mode 100644 index 0000000..4aa10fc Binary files /dev/null and b/fuzz/corpus/alloc_ops/ad7a7f8dd8618efaa22bf7553c8f01360731cf57 differ diff --git a/fuzz/corpus/alloc_ops/addccd507fde8e7f973587449e4879eac2f43332 b/fuzz/corpus/alloc_ops/addccd507fde8e7f973587449e4879eac2f43332 new file mode 100644 index 0000000..e671491 Binary files /dev/null and b/fuzz/corpus/alloc_ops/addccd507fde8e7f973587449e4879eac2f43332 differ diff --git a/fuzz/corpus/alloc_ops/addd9c2ce24526129cd646c2de8cf078bd558693 b/fuzz/corpus/alloc_ops/addd9c2ce24526129cd646c2de8cf078bd558693 new file mode 100644 index 0000000..ffa59ae Binary files /dev/null and b/fuzz/corpus/alloc_ops/addd9c2ce24526129cd646c2de8cf078bd558693 differ diff --git a/fuzz/corpus/alloc_ops/adef59da9ed4cd5ae07f32d5d34763376e1cb791 b/fuzz/corpus/alloc_ops/adef59da9ed4cd5ae07f32d5d34763376e1cb791 new file mode 100644 index 0000000..23b6480 Binary files /dev/null and b/fuzz/corpus/alloc_ops/adef59da9ed4cd5ae07f32d5d34763376e1cb791 differ diff --git a/fuzz/corpus/alloc_ops/ae095732133d8de7e6b3d32668fcea0fcb0752e7 b/fuzz/corpus/alloc_ops/ae095732133d8de7e6b3d32668fcea0fcb0752e7 new file mode 100644 index 0000000..8d4390f Binary files /dev/null and b/fuzz/corpus/alloc_ops/ae095732133d8de7e6b3d32668fcea0fcb0752e7 differ diff --git a/fuzz/corpus/alloc_ops/ae0ded198ac9b69dc890a6473d94213c0affbaa4 b/fuzz/corpus/alloc_ops/ae0ded198ac9b69dc890a6473d94213c0affbaa4 new file mode 100644 index 0000000..947090f Binary files /dev/null and b/fuzz/corpus/alloc_ops/ae0ded198ac9b69dc890a6473d94213c0affbaa4 differ diff --git a/fuzz/corpus/alloc_ops/ae6094d5ef255a35992ea016ee3bde122e8c7aad b/fuzz/corpus/alloc_ops/ae6094d5ef255a35992ea016ee3bde122e8c7aad new file mode 100644 index 0000000..15b04f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ae6094d5ef255a35992ea016ee3bde122e8c7aad differ diff --git a/fuzz/corpus/alloc_ops/ae85fba4cd1b00ac690d246dff0b587a8f88f405 b/fuzz/corpus/alloc_ops/ae85fba4cd1b00ac690d246dff0b587a8f88f405 new file mode 100644 index 0000000..1846be2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ae85fba4cd1b00ac690d246dff0b587a8f88f405 differ diff --git a/fuzz/corpus/alloc_ops/aecca1e66e10b4677386b540b59413160e63cf10 b/fuzz/corpus/alloc_ops/aecca1e66e10b4677386b540b59413160e63cf10 new file mode 100644 index 0000000..794a65c Binary files /dev/null and b/fuzz/corpus/alloc_ops/aecca1e66e10b4677386b540b59413160e63cf10 differ diff --git a/fuzz/corpus/alloc_ops/af4f5ba923629df66965425a21ec71ef264498ea b/fuzz/corpus/alloc_ops/af4f5ba923629df66965425a21ec71ef264498ea new file mode 100644 index 0000000..7dd54c2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/af4f5ba923629df66965425a21ec71ef264498ea differ diff --git a/fuzz/corpus/alloc_ops/af5d2eecda6a11bf38a063fab43804a63cafc514 b/fuzz/corpus/alloc_ops/af5d2eecda6a11bf38a063fab43804a63cafc514 new file mode 100644 index 0000000..8b4b306 Binary files /dev/null and b/fuzz/corpus/alloc_ops/af5d2eecda6a11bf38a063fab43804a63cafc514 differ diff --git a/fuzz/corpus/alloc_ops/af63a62e112a2acc86ed9ff51868a1756e135887 b/fuzz/corpus/alloc_ops/af63a62e112a2acc86ed9ff51868a1756e135887 new file mode 100644 index 0000000..9d5e4b6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/af63a62e112a2acc86ed9ff51868a1756e135887 differ diff --git a/fuzz/corpus/alloc_ops/af977a3ea8ed5f07abd598236601f07e37d07ef9 b/fuzz/corpus/alloc_ops/af977a3ea8ed5f07abd598236601f07e37d07ef9 new file mode 100644 index 0000000..cdf9d2b Binary files /dev/null and b/fuzz/corpus/alloc_ops/af977a3ea8ed5f07abd598236601f07e37d07ef9 differ diff --git a/fuzz/corpus/alloc_ops/afb5bfb6903a9e06a523357db045d2862a0267ff b/fuzz/corpus/alloc_ops/afb5bfb6903a9e06a523357db045d2862a0267ff new file mode 100644 index 0000000..0ec0da2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/afb5bfb6903a9e06a523357db045d2862a0267ff differ diff --git a/fuzz/corpus/alloc_ops/b0018f294ea97729fd471256db62fa64c126f192 b/fuzz/corpus/alloc_ops/b0018f294ea97729fd471256db62fa64c126f192 new file mode 100644 index 0000000..b1d30ea Binary files /dev/null and b/fuzz/corpus/alloc_ops/b0018f294ea97729fd471256db62fa64c126f192 differ diff --git a/fuzz/corpus/alloc_ops/b00421658522f927c6b62db799b778d4faf9e733 b/fuzz/corpus/alloc_ops/b00421658522f927c6b62db799b778d4faf9e733 new file mode 100644 index 0000000..58a627c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b00421658522f927c6b62db799b778d4faf9e733 differ diff --git a/fuzz/corpus/alloc_ops/b007517da292b3cb2e2cf45add9be5d4d89915b8 b/fuzz/corpus/alloc_ops/b007517da292b3cb2e2cf45add9be5d4d89915b8 new file mode 100644 index 0000000..3db58c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b007517da292b3cb2e2cf45add9be5d4d89915b8 differ diff --git a/fuzz/corpus/alloc_ops/b017d9ee689ea0930071befda4b52dec880d282d b/fuzz/corpus/alloc_ops/b017d9ee689ea0930071befda4b52dec880d282d new file mode 100644 index 0000000..2cbfd42 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b017d9ee689ea0930071befda4b52dec880d282d differ diff --git a/fuzz/corpus/alloc_ops/b02329176123c8db1aaefc5bec1a561584aa50d9 b/fuzz/corpus/alloc_ops/b02329176123c8db1aaefc5bec1a561584aa50d9 new file mode 100644 index 0000000..15b6bd3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b02329176123c8db1aaefc5bec1a561584aa50d9 differ diff --git a/fuzz/corpus/alloc_ops/b0503555e40311ed5e24a981d8ac97d324a85e45 b/fuzz/corpus/alloc_ops/b0503555e40311ed5e24a981d8ac97d324a85e45 new file mode 100644 index 0000000..7f74e2e Binary files /dev/null and b/fuzz/corpus/alloc_ops/b0503555e40311ed5e24a981d8ac97d324a85e45 differ diff --git a/fuzz/corpus/alloc_ops/b0557a9438e47d29a145de10e3408ba1a5370468 b/fuzz/corpus/alloc_ops/b0557a9438e47d29a145de10e3408ba1a5370468 new file mode 100644 index 0000000..759601e Binary files /dev/null and b/fuzz/corpus/alloc_ops/b0557a9438e47d29a145de10e3408ba1a5370468 differ diff --git a/fuzz/corpus/alloc_ops/b07ab14edbb00934868a50617c7ae8e8200a5952 b/fuzz/corpus/alloc_ops/b07ab14edbb00934868a50617c7ae8e8200a5952 new file mode 100644 index 0000000..9a882fe Binary files /dev/null and b/fuzz/corpus/alloc_ops/b07ab14edbb00934868a50617c7ae8e8200a5952 differ diff --git a/fuzz/corpus/alloc_ops/b11f14407721cc06f95ed44c551379b754626815 b/fuzz/corpus/alloc_ops/b11f14407721cc06f95ed44c551379b754626815 new file mode 100644 index 0000000..40a146e Binary files /dev/null and b/fuzz/corpus/alloc_ops/b11f14407721cc06f95ed44c551379b754626815 differ diff --git a/fuzz/corpus/alloc_ops/b169e903968b878ef4e60aa06a7b2d6b15fce0b0 b/fuzz/corpus/alloc_ops/b169e903968b878ef4e60aa06a7b2d6b15fce0b0 new file mode 100644 index 0000000..c673781 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b169e903968b878ef4e60aa06a7b2d6b15fce0b0 differ diff --git a/fuzz/corpus/alloc_ops/b16fbfa98346d7c50a5e21db7b253f1fdf5f1674 b/fuzz/corpus/alloc_ops/b16fbfa98346d7c50a5e21db7b253f1fdf5f1674 new file mode 100644 index 0000000..05613aa Binary files /dev/null and b/fuzz/corpus/alloc_ops/b16fbfa98346d7c50a5e21db7b253f1fdf5f1674 differ diff --git a/fuzz/corpus/alloc_ops/b19885fd00aed2f01e96e499d19fe64f69ed67aa b/fuzz/corpus/alloc_ops/b19885fd00aed2f01e96e499d19fe64f69ed67aa new file mode 100644 index 0000000..0c55e4b Binary files /dev/null and b/fuzz/corpus/alloc_ops/b19885fd00aed2f01e96e499d19fe64f69ed67aa differ diff --git a/fuzz/corpus/alloc_ops/b1a84fc57068fc63052217298b7a222e75992b8b b/fuzz/corpus/alloc_ops/b1a84fc57068fc63052217298b7a222e75992b8b new file mode 100644 index 0000000..a705f7a Binary files /dev/null and b/fuzz/corpus/alloc_ops/b1a84fc57068fc63052217298b7a222e75992b8b differ diff --git a/fuzz/corpus/alloc_ops/b1d617c38357f8844a56fcabd680cc4ee03d73a1 b/fuzz/corpus/alloc_ops/b1d617c38357f8844a56fcabd680cc4ee03d73a1 new file mode 100644 index 0000000..639639d Binary files /dev/null and b/fuzz/corpus/alloc_ops/b1d617c38357f8844a56fcabd680cc4ee03d73a1 differ diff --git a/fuzz/corpus/alloc_ops/b1f60a6b002345cd36ce3b81d68fab8a8cdb60ac b/fuzz/corpus/alloc_ops/b1f60a6b002345cd36ce3b81d68fab8a8cdb60ac new file mode 100644 index 0000000..ac1fed8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b1f60a6b002345cd36ce3b81d68fab8a8cdb60ac differ diff --git a/fuzz/corpus/alloc_ops/b1fb3e02b57b829abc6bbe9ce9a1d350bcad6d2e b/fuzz/corpus/alloc_ops/b1fb3e02b57b829abc6bbe9ce9a1d350bcad6d2e new file mode 100644 index 0000000..13a0940 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b1fb3e02b57b829abc6bbe9ce9a1d350bcad6d2e differ diff --git a/fuzz/corpus/alloc_ops/b207d4f156893787c089bf3003babf06df01b693 b/fuzz/corpus/alloc_ops/b207d4f156893787c089bf3003babf06df01b693 new file mode 100644 index 0000000..dd0e6b1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b207d4f156893787c089bf3003babf06df01b693 differ diff --git a/fuzz/corpus/alloc_ops/b209bcc1ccca7ce5f86817e63982f6a243a60622 b/fuzz/corpus/alloc_ops/b209bcc1ccca7ce5f86817e63982f6a243a60622 new file mode 100644 index 0000000..7ccdf2c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b209bcc1ccca7ce5f86817e63982f6a243a60622 differ diff --git a/fuzz/corpus/alloc_ops/b22537ed3712121ad795fa6018433a7cb304b993 b/fuzz/corpus/alloc_ops/b22537ed3712121ad795fa6018433a7cb304b993 new file mode 100644 index 0000000..a9bc398 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b22537ed3712121ad795fa6018433a7cb304b993 differ diff --git a/fuzz/corpus/alloc_ops/b22cd07c069b535b0735782bcc2aab8648618ec7 b/fuzz/corpus/alloc_ops/b22cd07c069b535b0735782bcc2aab8648618ec7 new file mode 100644 index 0000000..f8b674d Binary files /dev/null and b/fuzz/corpus/alloc_ops/b22cd07c069b535b0735782bcc2aab8648618ec7 differ diff --git a/fuzz/corpus/alloc_ops/b2333598253b1cee2f75c6be5993f7033a38c783 b/fuzz/corpus/alloc_ops/b2333598253b1cee2f75c6be5993f7033a38c783 new file mode 100644 index 0000000..df37bca Binary files /dev/null and b/fuzz/corpus/alloc_ops/b2333598253b1cee2f75c6be5993f7033a38c783 differ diff --git a/fuzz/corpus/alloc_ops/b25a0e601bcca3e44ea4cfe0524e6e28764a6279 b/fuzz/corpus/alloc_ops/b25a0e601bcca3e44ea4cfe0524e6e28764a6279 new file mode 100644 index 0000000..2af8d5f Binary files /dev/null and b/fuzz/corpus/alloc_ops/b25a0e601bcca3e44ea4cfe0524e6e28764a6279 differ diff --git a/fuzz/corpus/alloc_ops/b2998cb7e9481d5e804a7b7df80d7c2df59912dc b/fuzz/corpus/alloc_ops/b2998cb7e9481d5e804a7b7df80d7c2df59912dc new file mode 100644 index 0000000..5809aa5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b2998cb7e9481d5e804a7b7df80d7c2df59912dc differ diff --git a/fuzz/corpus/alloc_ops/b2ccde8517c264d61fb00ef3b10c3a9b84bc4fe6 b/fuzz/corpus/alloc_ops/b2ccde8517c264d61fb00ef3b10c3a9b84bc4fe6 new file mode 100644 index 0000000..8aedf31 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b2ccde8517c264d61fb00ef3b10c3a9b84bc4fe6 differ diff --git a/fuzz/corpus/alloc_ops/b2e72e1a983275aaf1871f8e32bb02e057ef13dd b/fuzz/corpus/alloc_ops/b2e72e1a983275aaf1871f8e32bb02e057ef13dd new file mode 100644 index 0000000..005bfb7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b2e72e1a983275aaf1871f8e32bb02e057ef13dd differ diff --git a/fuzz/corpus/alloc_ops/b2ec640c15b6a3343bdac4a6d53c45c5f6b09c53 b/fuzz/corpus/alloc_ops/b2ec640c15b6a3343bdac4a6d53c45c5f6b09c53 new file mode 100644 index 0000000..e06578c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b2ec640c15b6a3343bdac4a6d53c45c5f6b09c53 differ diff --git a/fuzz/corpus/alloc_ops/b34f2aa3ede2083df88c55f2b1d8f81fb4b70cd2 b/fuzz/corpus/alloc_ops/b34f2aa3ede2083df88c55f2b1d8f81fb4b70cd2 new file mode 100644 index 0000000..f45d5f1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b34f2aa3ede2083df88c55f2b1d8f81fb4b70cd2 differ diff --git a/fuzz/corpus/alloc_ops/b37b8bb665659602e037a4e13839e944ce07d345 b/fuzz/corpus/alloc_ops/b37b8bb665659602e037a4e13839e944ce07d345 new file mode 100644 index 0000000..ee7aef6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b37b8bb665659602e037a4e13839e944ce07d345 differ diff --git a/fuzz/corpus/alloc_ops/b38165c92e4cae72cf5e8fd35241f0b7a513b9a6 b/fuzz/corpus/alloc_ops/b38165c92e4cae72cf5e8fd35241f0b7a513b9a6 new file mode 100644 index 0000000..a735363 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b38165c92e4cae72cf5e8fd35241f0b7a513b9a6 differ diff --git a/fuzz/corpus/alloc_ops/b38412eb0d168e0cf33f17ce16311d2e0dee3347 b/fuzz/corpus/alloc_ops/b38412eb0d168e0cf33f17ce16311d2e0dee3347 new file mode 100644 index 0000000..dcf13e6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b38412eb0d168e0cf33f17ce16311d2e0dee3347 differ diff --git a/fuzz/corpus/alloc_ops/b385cf59fae7856d4bbc3f4013b16792ab3d261a b/fuzz/corpus/alloc_ops/b385cf59fae7856d4bbc3f4013b16792ab3d261a new file mode 100644 index 0000000..1246b73 --- /dev/null +++ b/fuzz/corpus/alloc_ops/b385cf59fae7856d4bbc3f4013b16792ab3d261a @@ -0,0 +1 @@ +Œr#ÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/b3ac864a23bff31b75494b513a71abe19e0b21b4 b/fuzz/corpus/alloc_ops/b3ac864a23bff31b75494b513a71abe19e0b21b4 new file mode 100644 index 0000000..081f9a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b3ac864a23bff31b75494b513a71abe19e0b21b4 differ diff --git a/fuzz/corpus/alloc_ops/b3af42d7c9d14e1ace6c5a0683f87e85ac073ad4 b/fuzz/corpus/alloc_ops/b3af42d7c9d14e1ace6c5a0683f87e85ac073ad4 new file mode 100644 index 0000000..49dfe06 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b3af42d7c9d14e1ace6c5a0683f87e85ac073ad4 differ diff --git a/fuzz/corpus/alloc_ops/b3b09d08d1fda6467894497457a8758ee7ec377b b/fuzz/corpus/alloc_ops/b3b09d08d1fda6467894497457a8758ee7ec377b new file mode 100644 index 0000000..f9a81cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/b3b09d08d1fda6467894497457a8758ee7ec377b differ diff --git a/fuzz/corpus/alloc_ops/b3b6020995721982fce620d4fbe0e66a803a363d b/fuzz/corpus/alloc_ops/b3b6020995721982fce620d4fbe0e66a803a363d new file mode 100644 index 0000000..8834e4d Binary files /dev/null and b/fuzz/corpus/alloc_ops/b3b6020995721982fce620d4fbe0e66a803a363d differ diff --git a/fuzz/corpus/alloc_ops/b3dc0eb85823c4947d8e670aa467cf95351b5294 b/fuzz/corpus/alloc_ops/b3dc0eb85823c4947d8e670aa467cf95351b5294 new file mode 100644 index 0000000..bee381c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b3dc0eb85823c4947d8e670aa467cf95351b5294 differ diff --git a/fuzz/corpus/alloc_ops/b44a0dd515295828addf3af325de3d47f3dc4943 b/fuzz/corpus/alloc_ops/b44a0dd515295828addf3af325de3d47f3dc4943 new file mode 100644 index 0000000..fdc94f6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b44a0dd515295828addf3af325de3d47f3dc4943 differ diff --git a/fuzz/corpus/alloc_ops/b47b8fda4d318d82681a4fe3c9800f8bb93ff0ad b/fuzz/corpus/alloc_ops/b47b8fda4d318d82681a4fe3c9800f8bb93ff0ad new file mode 100644 index 0000000..66d3ba3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b47b8fda4d318d82681a4fe3c9800f8bb93ff0ad differ diff --git a/fuzz/corpus/alloc_ops/b47c0a47985e09ee59eb45e83179ec2603fda729 b/fuzz/corpus/alloc_ops/b47c0a47985e09ee59eb45e83179ec2603fda729 new file mode 100644 index 0000000..afd6c28 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b47c0a47985e09ee59eb45e83179ec2603fda729 differ diff --git a/fuzz/corpus/alloc_ops/b486b1bb14305c326014cae08b73ea724758247f b/fuzz/corpus/alloc_ops/b486b1bb14305c326014cae08b73ea724758247f new file mode 100644 index 0000000..274c9b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b486b1bb14305c326014cae08b73ea724758247f differ diff --git a/fuzz/corpus/alloc_ops/b4d841ae33d83b1f692c1468efff8ef56dac0929 b/fuzz/corpus/alloc_ops/b4d841ae33d83b1f692c1468efff8ef56dac0929 new file mode 100644 index 0000000..3363b80 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b4d841ae33d83b1f692c1468efff8ef56dac0929 differ diff --git a/fuzz/corpus/alloc_ops/b52b3a9549692693931386de420be67b1c729cb0 b/fuzz/corpus/alloc_ops/b52b3a9549692693931386de420be67b1c729cb0 new file mode 100644 index 0000000..911ec13 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b52b3a9549692693931386de420be67b1c729cb0 differ diff --git a/fuzz/corpus/alloc_ops/b583ceacdf0dc68db7153bdd9f0967cc3c194146 b/fuzz/corpus/alloc_ops/b583ceacdf0dc68db7153bdd9f0967cc3c194146 new file mode 100644 index 0000000..06ec09c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b583ceacdf0dc68db7153bdd9f0967cc3c194146 differ diff --git a/fuzz/corpus/alloc_ops/b5f0bab5843a39c21af92c4a7e69e13d4f47557d b/fuzz/corpus/alloc_ops/b5f0bab5843a39c21af92c4a7e69e13d4f47557d new file mode 100644 index 0000000..9587500 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b5f0bab5843a39c21af92c4a7e69e13d4f47557d differ diff --git a/fuzz/corpus/alloc_ops/b60fb98db4294814afae9d67b745c13d102fdbbf b/fuzz/corpus/alloc_ops/b60fb98db4294814afae9d67b745c13d102fdbbf new file mode 100644 index 0000000..dca94ea Binary files /dev/null and b/fuzz/corpus/alloc_ops/b60fb98db4294814afae9d67b745c13d102fdbbf differ diff --git a/fuzz/corpus/alloc_ops/b620e68f4f0060dab9880419cd19942195840198 b/fuzz/corpus/alloc_ops/b620e68f4f0060dab9880419cd19942195840198 new file mode 100644 index 0000000..6bc0edb Binary files /dev/null and b/fuzz/corpus/alloc_ops/b620e68f4f0060dab9880419cd19942195840198 differ diff --git a/fuzz/corpus/alloc_ops/b63e493aac9675111476106657ed0ff8a604d662 b/fuzz/corpus/alloc_ops/b63e493aac9675111476106657ed0ff8a604d662 new file mode 100644 index 0000000..7adcfc5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b63e493aac9675111476106657ed0ff8a604d662 differ diff --git a/fuzz/corpus/alloc_ops/b68c1c81e897e8244fd852548507ee16017bd048 b/fuzz/corpus/alloc_ops/b68c1c81e897e8244fd852548507ee16017bd048 new file mode 100644 index 0000000..f066088 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b68c1c81e897e8244fd852548507ee16017bd048 differ diff --git a/fuzz/corpus/alloc_ops/b69174dde61cdac3118aa50c684514a187470067 b/fuzz/corpus/alloc_ops/b69174dde61cdac3118aa50c684514a187470067 new file mode 100644 index 0000000..72b3e76 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b69174dde61cdac3118aa50c684514a187470067 differ diff --git a/fuzz/corpus/alloc_ops/b6d934143a9dfe9db903c91e5c315786ba5e9a4d b/fuzz/corpus/alloc_ops/b6d934143a9dfe9db903c91e5c315786ba5e9a4d new file mode 100644 index 0000000..d7a7b3e Binary files /dev/null and b/fuzz/corpus/alloc_ops/b6d934143a9dfe9db903c91e5c315786ba5e9a4d differ diff --git a/fuzz/corpus/alloc_ops/b6ef84ded853398450b5d3aa868cc40773bef97a b/fuzz/corpus/alloc_ops/b6ef84ded853398450b5d3aa868cc40773bef97a new file mode 100644 index 0000000..66141db Binary files /dev/null and b/fuzz/corpus/alloc_ops/b6ef84ded853398450b5d3aa868cc40773bef97a differ diff --git a/fuzz/corpus/alloc_ops/b6f058dc89b39b828dbc09e0e2bea947f8d77672 b/fuzz/corpus/alloc_ops/b6f058dc89b39b828dbc09e0e2bea947f8d77672 new file mode 100644 index 0000000..25f23a8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b6f058dc89b39b828dbc09e0e2bea947f8d77672 differ diff --git a/fuzz/corpus/alloc_ops/b724dc48a9825e9786c3dd62e267873dd8faac87 b/fuzz/corpus/alloc_ops/b724dc48a9825e9786c3dd62e267873dd8faac87 new file mode 100644 index 0000000..a5dbe77 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b724dc48a9825e9786c3dd62e267873dd8faac87 differ diff --git a/fuzz/corpus/alloc_ops/b736dcb24dad5ace5cd022ac955d79546592686b b/fuzz/corpus/alloc_ops/b736dcb24dad5ace5cd022ac955d79546592686b new file mode 100644 index 0000000..e87ab80 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b736dcb24dad5ace5cd022ac955d79546592686b differ diff --git a/fuzz/corpus/alloc_ops/b777ac8875bab0284c79ebac50934c4352975b27 b/fuzz/corpus/alloc_ops/b777ac8875bab0284c79ebac50934c4352975b27 new file mode 100644 index 0000000..5f0af5c Binary files /dev/null and b/fuzz/corpus/alloc_ops/b777ac8875bab0284c79ebac50934c4352975b27 differ diff --git a/fuzz/corpus/alloc_ops/b788b09941f5b592ad4f0cf4e97ece440da7cf2a b/fuzz/corpus/alloc_ops/b788b09941f5b592ad4f0cf4e97ece440da7cf2a new file mode 100644 index 0000000..4daaae5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b788b09941f5b592ad4f0cf4e97ece440da7cf2a differ diff --git a/fuzz/corpus/alloc_ops/b79bf3274627ca12cb7c8a7311f9a277b3af08eb b/fuzz/corpus/alloc_ops/b79bf3274627ca12cb7c8a7311f9a277b3af08eb new file mode 100644 index 0000000..c1d705e Binary files /dev/null and b/fuzz/corpus/alloc_ops/b79bf3274627ca12cb7c8a7311f9a277b3af08eb differ diff --git a/fuzz/corpus/alloc_ops/b80df5c52a1b2eeef31166a8d06b7eebd47c8b2f b/fuzz/corpus/alloc_ops/b80df5c52a1b2eeef31166a8d06b7eebd47c8b2f new file mode 100644 index 0000000..bbf43ef Binary files /dev/null and b/fuzz/corpus/alloc_ops/b80df5c52a1b2eeef31166a8d06b7eebd47c8b2f differ diff --git a/fuzz/corpus/alloc_ops/b829b3e17cbe5d7a419a5ba79fe688635a7f5bc2 b/fuzz/corpus/alloc_ops/b829b3e17cbe5d7a419a5ba79fe688635a7f5bc2 new file mode 100644 index 0000000..fdf72fd Binary files /dev/null and b/fuzz/corpus/alloc_ops/b829b3e17cbe5d7a419a5ba79fe688635a7f5bc2 differ diff --git a/fuzz/corpus/alloc_ops/b851f8f2a3bfa5ef54fff7dd0216994bc964e761 b/fuzz/corpus/alloc_ops/b851f8f2a3bfa5ef54fff7dd0216994bc964e761 new file mode 100644 index 0000000..63615f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b851f8f2a3bfa5ef54fff7dd0216994bc964e761 differ diff --git a/fuzz/corpus/alloc_ops/b8a10592a7d2a3d4d81826c2938a1c3c046b3e39 b/fuzz/corpus/alloc_ops/b8a10592a7d2a3d4d81826c2938a1c3c046b3e39 new file mode 100644 index 0000000..79c206a --- /dev/null +++ b/fuzz/corpus/alloc_ops/b8a10592a7d2a3d4d81826c2938a1c3c046b3e39 @@ -0,0 +1 @@ +€ÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/b8b327241f94a49c71927523d296e209bde161d0 b/fuzz/corpus/alloc_ops/b8b327241f94a49c71927523d296e209bde161d0 new file mode 100644 index 0000000..e929fe3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b8b327241f94a49c71927523d296e209bde161d0 differ diff --git a/fuzz/corpus/alloc_ops/b8fcfb87375153a840cfdce2527cac5904aff83e b/fuzz/corpus/alloc_ops/b8fcfb87375153a840cfdce2527cac5904aff83e new file mode 100644 index 0000000..506e694 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b8fcfb87375153a840cfdce2527cac5904aff83e differ diff --git a/fuzz/corpus/alloc_ops/b915bf0d142ce39e933069df42e99589df7e55e2 b/fuzz/corpus/alloc_ops/b915bf0d142ce39e933069df42e99589df7e55e2 new file mode 100644 index 0000000..14e4d00 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b915bf0d142ce39e933069df42e99589df7e55e2 differ diff --git a/fuzz/corpus/alloc_ops/b96de2c8d3023440e1df4a224908ac349484e2d6 b/fuzz/corpus/alloc_ops/b96de2c8d3023440e1df4a224908ac349484e2d6 new file mode 100644 index 0000000..4a16be1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b96de2c8d3023440e1df4a224908ac349484e2d6 differ diff --git a/fuzz/corpus/alloc_ops/b9b46152ce75e5c49cc72c3d361342f36551d276 b/fuzz/corpus/alloc_ops/b9b46152ce75e5c49cc72c3d361342f36551d276 new file mode 100644 index 0000000..bd5b92d Binary files /dev/null and b/fuzz/corpus/alloc_ops/b9b46152ce75e5c49cc72c3d361342f36551d276 differ diff --git a/fuzz/corpus/alloc_ops/b9bae3c1c116082ab0e2ef5f045e0f175053968f b/fuzz/corpus/alloc_ops/b9bae3c1c116082ab0e2ef5f045e0f175053968f new file mode 100644 index 0000000..03eeb15 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b9bae3c1c116082ab0e2ef5f045e0f175053968f differ diff --git a/fuzz/corpus/alloc_ops/b9de139cfda6861d5496910b279db2abe8ca94f0 b/fuzz/corpus/alloc_ops/b9de139cfda6861d5496910b279db2abe8ca94f0 new file mode 100644 index 0000000..f936381 Binary files /dev/null and b/fuzz/corpus/alloc_ops/b9de139cfda6861d5496910b279db2abe8ca94f0 differ diff --git a/fuzz/corpus/alloc_ops/ba2570d8ad0720ded0a3245306c088ab901c983b b/fuzz/corpus/alloc_ops/ba2570d8ad0720ded0a3245306c088ab901c983b new file mode 100644 index 0000000..0a26a1a Binary files /dev/null and b/fuzz/corpus/alloc_ops/ba2570d8ad0720ded0a3245306c088ab901c983b differ diff --git a/fuzz/corpus/alloc_ops/ba82c214d4a1d44a04887e25fa6eb0efe87dde9a b/fuzz/corpus/alloc_ops/ba82c214d4a1d44a04887e25fa6eb0efe87dde9a new file mode 100644 index 0000000..a580120 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ba82c214d4a1d44a04887e25fa6eb0efe87dde9a differ diff --git a/fuzz/corpus/alloc_ops/bae41fd5fdea4a1b96d61132492b2ac46025f6be b/fuzz/corpus/alloc_ops/bae41fd5fdea4a1b96d61132492b2ac46025f6be new file mode 100644 index 0000000..28b6a58 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bae41fd5fdea4a1b96d61132492b2ac46025f6be differ diff --git a/fuzz/corpus/alloc_ops/baea253a5a629cd37d7c345ad9a5857f093ebc91 b/fuzz/corpus/alloc_ops/baea253a5a629cd37d7c345ad9a5857f093ebc91 new file mode 100644 index 0000000..bca31b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/baea253a5a629cd37d7c345ad9a5857f093ebc91 differ diff --git a/fuzz/corpus/alloc_ops/bafb39fdbd03997e0a2648ba2501fe377e955a8c b/fuzz/corpus/alloc_ops/bafb39fdbd03997e0a2648ba2501fe377e955a8c new file mode 100644 index 0000000..7ee94d2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bafb39fdbd03997e0a2648ba2501fe377e955a8c differ diff --git a/fuzz/corpus/alloc_ops/bb108ca73765ab6b1c997e3803aef545888dfa7f b/fuzz/corpus/alloc_ops/bb108ca73765ab6b1c997e3803aef545888dfa7f new file mode 100644 index 0000000..be5fdb4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb108ca73765ab6b1c997e3803aef545888dfa7f differ diff --git a/fuzz/corpus/alloc_ops/bb1a1f936ea1d4c082b1ccaac58907293e0be463 b/fuzz/corpus/alloc_ops/bb1a1f936ea1d4c082b1ccaac58907293e0be463 new file mode 100644 index 0000000..ed12ec6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb1a1f936ea1d4c082b1ccaac58907293e0be463 differ diff --git a/fuzz/corpus/alloc_ops/bb24da514781502edf2c71258ac69930b7826105 b/fuzz/corpus/alloc_ops/bb24da514781502edf2c71258ac69930b7826105 new file mode 100644 index 0000000..1c77b1f Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb24da514781502edf2c71258ac69930b7826105 differ diff --git a/fuzz/corpus/alloc_ops/bb2eccf3490e0b86fdb9b8c0b054847c20e69745 b/fuzz/corpus/alloc_ops/bb2eccf3490e0b86fdb9b8c0b054847c20e69745 new file mode 100644 index 0000000..96169d4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb2eccf3490e0b86fdb9b8c0b054847c20e69745 differ diff --git a/fuzz/corpus/alloc_ops/bb3dbee963f2bf9b2985c97c0a9a0edbb2951b1b b/fuzz/corpus/alloc_ops/bb3dbee963f2bf9b2985c97c0a9a0edbb2951b1b new file mode 100644 index 0000000..47d7e6d Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb3dbee963f2bf9b2985c97c0a9a0edbb2951b1b differ diff --git a/fuzz/corpus/alloc_ops/bb3edad3089b11018e4c9e0626c5cb7aeed257a1 b/fuzz/corpus/alloc_ops/bb3edad3089b11018e4c9e0626c5cb7aeed257a1 new file mode 100644 index 0000000..18a8dc4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bb3edad3089b11018e4c9e0626c5cb7aeed257a1 differ diff --git a/fuzz/corpus/alloc_ops/bbb07de367d90651251dac965ef49a6c8b857094 b/fuzz/corpus/alloc_ops/bbb07de367d90651251dac965ef49a6c8b857094 new file mode 100644 index 0000000..5080c09 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bbb07de367d90651251dac965ef49a6c8b857094 differ diff --git a/fuzz/corpus/alloc_ops/bbd3267e7bbf2b221fd19ca9257cf349e66f4627 b/fuzz/corpus/alloc_ops/bbd3267e7bbf2b221fd19ca9257cf349e66f4627 new file mode 100644 index 0000000..07b957a Binary files /dev/null and b/fuzz/corpus/alloc_ops/bbd3267e7bbf2b221fd19ca9257cf349e66f4627 differ diff --git a/fuzz/corpus/alloc_ops/bc0991cd8a24d3b67b1381e8d9f0662f63f01944 b/fuzz/corpus/alloc_ops/bc0991cd8a24d3b67b1381e8d9f0662f63f01944 new file mode 100644 index 0000000..b2678a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bc0991cd8a24d3b67b1381e8d9f0662f63f01944 differ diff --git a/fuzz/corpus/alloc_ops/bc5ba83414e587e44af24e4ad84811e1f0b9da35 b/fuzz/corpus/alloc_ops/bc5ba83414e587e44af24e4ad84811e1f0b9da35 new file mode 100644 index 0000000..26f80c0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bc5ba83414e587e44af24e4ad84811e1f0b9da35 differ diff --git a/fuzz/corpus/alloc_ops/bc6f31f522f71f653971e7c61274a476cdd319f1 b/fuzz/corpus/alloc_ops/bc6f31f522f71f653971e7c61274a476cdd319f1 new file mode 100644 index 0000000..c59344c Binary files /dev/null and b/fuzz/corpus/alloc_ops/bc6f31f522f71f653971e7c61274a476cdd319f1 differ diff --git a/fuzz/corpus/alloc_ops/bcca046c159bf338addd9f446ca4509d48106f0c b/fuzz/corpus/alloc_ops/bcca046c159bf338addd9f446ca4509d48106f0c new file mode 100644 index 0000000..dffde6f Binary files /dev/null and b/fuzz/corpus/alloc_ops/bcca046c159bf338addd9f446ca4509d48106f0c differ diff --git a/fuzz/corpus/alloc_ops/bcd5441b29d52b9a720b719b1eda6b4acd9c80a0 b/fuzz/corpus/alloc_ops/bcd5441b29d52b9a720b719b1eda6b4acd9c80a0 new file mode 100644 index 0000000..8020c5c Binary files /dev/null and b/fuzz/corpus/alloc_ops/bcd5441b29d52b9a720b719b1eda6b4acd9c80a0 differ diff --git a/fuzz/corpus/alloc_ops/bd0cfaecb5328212f195db6c472a6a9308ea049c b/fuzz/corpus/alloc_ops/bd0cfaecb5328212f195db6c472a6a9308ea049c new file mode 100644 index 0000000..2f0b3a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bd0cfaecb5328212f195db6c472a6a9308ea049c differ diff --git a/fuzz/corpus/alloc_ops/bd30fc0643f84a470795526f9ff3a8f920020106 b/fuzz/corpus/alloc_ops/bd30fc0643f84a470795526f9ff3a8f920020106 new file mode 100644 index 0000000..343de56 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bd30fc0643f84a470795526f9ff3a8f920020106 differ diff --git a/fuzz/corpus/alloc_ops/bda5b92e8d2c886b0a01c675b8e7032862fd8ff8 b/fuzz/corpus/alloc_ops/bda5b92e8d2c886b0a01c675b8e7032862fd8ff8 new file mode 100644 index 0000000..2ee2391 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bda5b92e8d2c886b0a01c675b8e7032862fd8ff8 differ diff --git a/fuzz/corpus/alloc_ops/bde8eeac56f29e9a8669dc5d92d7a80b03e7a936 b/fuzz/corpus/alloc_ops/bde8eeac56f29e9a8669dc5d92d7a80b03e7a936 new file mode 100644 index 0000000..f94fc93 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bde8eeac56f29e9a8669dc5d92d7a80b03e7a936 differ diff --git a/fuzz/corpus/alloc_ops/be282e1e8338228285cfe7110d7f2a565665c6b6 b/fuzz/corpus/alloc_ops/be282e1e8338228285cfe7110d7f2a565665c6b6 new file mode 100644 index 0000000..8e457a1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/be282e1e8338228285cfe7110d7f2a565665c6b6 differ diff --git a/fuzz/corpus/alloc_ops/be461579d4e836b84962c0be4bbee30ecf40f13c b/fuzz/corpus/alloc_ops/be461579d4e836b84962c0be4bbee30ecf40f13c new file mode 100644 index 0000000..cd603c2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/be461579d4e836b84962c0be4bbee30ecf40f13c differ diff --git a/fuzz/corpus/alloc_ops/be46d1824851b508daad5ccc016937e48e758244 b/fuzz/corpus/alloc_ops/be46d1824851b508daad5ccc016937e48e758244 new file mode 100644 index 0000000..d7efbbc Binary files /dev/null and b/fuzz/corpus/alloc_ops/be46d1824851b508daad5ccc016937e48e758244 differ diff --git a/fuzz/corpus/alloc_ops/be56befd18dce9255c103475a0049dfbabbb3af4 b/fuzz/corpus/alloc_ops/be56befd18dce9255c103475a0049dfbabbb3af4 new file mode 100644 index 0000000..dfbf3b4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/be56befd18dce9255c103475a0049dfbabbb3af4 differ diff --git a/fuzz/corpus/alloc_ops/be63c0c72edd9e95ebe42afdf277e90b4b6b3ff6 b/fuzz/corpus/alloc_ops/be63c0c72edd9e95ebe42afdf277e90b4b6b3ff6 new file mode 100644 index 0000000..6dd9d47 Binary files /dev/null and b/fuzz/corpus/alloc_ops/be63c0c72edd9e95ebe42afdf277e90b4b6b3ff6 differ diff --git a/fuzz/corpus/alloc_ops/be8bd7d117e357e68a6811f1a6a3213104e4f020 b/fuzz/corpus/alloc_ops/be8bd7d117e357e68a6811f1a6a3213104e4f020 new file mode 100644 index 0000000..aef55ee Binary files /dev/null and b/fuzz/corpus/alloc_ops/be8bd7d117e357e68a6811f1a6a3213104e4f020 differ diff --git a/fuzz/corpus/alloc_ops/bead08aa9963df7997ee17c5a119c2756dabddfe b/fuzz/corpus/alloc_ops/bead08aa9963df7997ee17c5a119c2756dabddfe new file mode 100644 index 0000000..9da14f9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bead08aa9963df7997ee17c5a119c2756dabddfe differ diff --git a/fuzz/corpus/alloc_ops/bf0e1efb475688843a737d637846d67688c078aa b/fuzz/corpus/alloc_ops/bf0e1efb475688843a737d637846d67688c078aa new file mode 100644 index 0000000..4ee969c Binary files /dev/null and b/fuzz/corpus/alloc_ops/bf0e1efb475688843a737d637846d67688c078aa differ diff --git a/fuzz/corpus/alloc_ops/bf3774d8c0008875566e37649f6c900834fb0853 b/fuzz/corpus/alloc_ops/bf3774d8c0008875566e37649f6c900834fb0853 new file mode 100644 index 0000000..54ce3c5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bf3774d8c0008875566e37649f6c900834fb0853 differ diff --git a/fuzz/corpus/alloc_ops/bf42de78e7e71443399de6f31c0250dbab6f1c4f b/fuzz/corpus/alloc_ops/bf42de78e7e71443399de6f31c0250dbab6f1c4f new file mode 100644 index 0000000..de74a89 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bf42de78e7e71443399de6f31c0250dbab6f1c4f differ diff --git a/fuzz/corpus/alloc_ops/bf4c7916212ac9151ef17ed992ff27a73778b2dc b/fuzz/corpus/alloc_ops/bf4c7916212ac9151ef17ed992ff27a73778b2dc new file mode 100644 index 0000000..b229fa3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bf4c7916212ac9151ef17ed992ff27a73778b2dc differ diff --git a/fuzz/corpus/alloc_ops/bfa94fc2591001fb7571d21fc844ba81293f160c b/fuzz/corpus/alloc_ops/bfa94fc2591001fb7571d21fc844ba81293f160c new file mode 100644 index 0000000..51e465f Binary files /dev/null and b/fuzz/corpus/alloc_ops/bfa94fc2591001fb7571d21fc844ba81293f160c differ diff --git a/fuzz/corpus/alloc_ops/bfbf5316282d43e4e5aa217178dfe0799fe738c9 b/fuzz/corpus/alloc_ops/bfbf5316282d43e4e5aa217178dfe0799fe738c9 new file mode 100644 index 0000000..320c58a Binary files /dev/null and b/fuzz/corpus/alloc_ops/bfbf5316282d43e4e5aa217178dfe0799fe738c9 differ diff --git a/fuzz/corpus/alloc_ops/bfd8d60e31bcb238ba68f06faffb93cef3639383 b/fuzz/corpus/alloc_ops/bfd8d60e31bcb238ba68f06faffb93cef3639383 new file mode 100644 index 0000000..9c309d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/bfd8d60e31bcb238ba68f06faffb93cef3639383 differ diff --git a/fuzz/corpus/alloc_ops/c02d20028c9d57a5054d08fd5604cca6cda82bf2 b/fuzz/corpus/alloc_ops/c02d20028c9d57a5054d08fd5604cca6cda82bf2 new file mode 100644 index 0000000..8d6041a Binary files /dev/null and b/fuzz/corpus/alloc_ops/c02d20028c9d57a5054d08fd5604cca6cda82bf2 differ diff --git a/fuzz/corpus/alloc_ops/c030d233f9b0340747dca6dd3e199644ae47fbfe b/fuzz/corpus/alloc_ops/c030d233f9b0340747dca6dd3e199644ae47fbfe new file mode 100644 index 0000000..1493232 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c030d233f9b0340747dca6dd3e199644ae47fbfe differ diff --git a/fuzz/corpus/alloc_ops/c04c57d526819702538b2f87f092fa1a9b0260da b/fuzz/corpus/alloc_ops/c04c57d526819702538b2f87f092fa1a9b0260da new file mode 100644 index 0000000..ad2225a Binary files /dev/null and b/fuzz/corpus/alloc_ops/c04c57d526819702538b2f87f092fa1a9b0260da differ diff --git a/fuzz/corpus/alloc_ops/c0baa9b54e71176033202ffb7f86e7a79961642c b/fuzz/corpus/alloc_ops/c0baa9b54e71176033202ffb7f86e7a79961642c new file mode 100644 index 0000000..c32b4bd Binary files /dev/null and b/fuzz/corpus/alloc_ops/c0baa9b54e71176033202ffb7f86e7a79961642c differ diff --git a/fuzz/corpus/alloc_ops/c0edb504391d1f65a2a9a344164bfbdb9bbda2e8 b/fuzz/corpus/alloc_ops/c0edb504391d1f65a2a9a344164bfbdb9bbda2e8 new file mode 100644 index 0000000..4769f9b Binary files /dev/null and b/fuzz/corpus/alloc_ops/c0edb504391d1f65a2a9a344164bfbdb9bbda2e8 differ diff --git a/fuzz/corpus/alloc_ops/c0f4e64b6ba04ee6af4a6e0c15ff0407de033869 b/fuzz/corpus/alloc_ops/c0f4e64b6ba04ee6af4a6e0c15ff0407de033869 new file mode 100644 index 0000000..f541147 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c0f4e64b6ba04ee6af4a6e0c15ff0407de033869 differ diff --git a/fuzz/corpus/alloc_ops/c101e4c4cd20a460f74e8b081f8241d1bef03167 b/fuzz/corpus/alloc_ops/c101e4c4cd20a460f74e8b081f8241d1bef03167 new file mode 100644 index 0000000..059d926 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c101e4c4cd20a460f74e8b081f8241d1bef03167 differ diff --git a/fuzz/corpus/alloc_ops/c126f8293d766d39daa4dd4933e3ed1c8ff24d0f b/fuzz/corpus/alloc_ops/c126f8293d766d39daa4dd4933e3ed1c8ff24d0f new file mode 100644 index 0000000..ad1cba6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c126f8293d766d39daa4dd4933e3ed1c8ff24d0f differ diff --git a/fuzz/corpus/alloc_ops/c14e89178e55fd6807c79245fcefae97d98cf05c b/fuzz/corpus/alloc_ops/c14e89178e55fd6807c79245fcefae97d98cf05c new file mode 100644 index 0000000..a006910 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c14e89178e55fd6807c79245fcefae97d98cf05c differ diff --git a/fuzz/corpus/alloc_ops/c1a9cddd2f3744642552ced92d887e08fe0f38b2 b/fuzz/corpus/alloc_ops/c1a9cddd2f3744642552ced92d887e08fe0f38b2 new file mode 100644 index 0000000..24924b1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c1a9cddd2f3744642552ced92d887e08fe0f38b2 differ diff --git a/fuzz/corpus/alloc_ops/c1d9173d78678ffb29976d56df752fdf323d01b8 b/fuzz/corpus/alloc_ops/c1d9173d78678ffb29976d56df752fdf323d01b8 new file mode 100644 index 0000000..3a5689f Binary files /dev/null and b/fuzz/corpus/alloc_ops/c1d9173d78678ffb29976d56df752fdf323d01b8 differ diff --git a/fuzz/corpus/alloc_ops/c1e38b18c1de564b53e277910c3ab3b3231ff4fc b/fuzz/corpus/alloc_ops/c1e38b18c1de564b53e277910c3ab3b3231ff4fc new file mode 100644 index 0000000..b25be90 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c1e38b18c1de564b53e277910c3ab3b3231ff4fc differ diff --git a/fuzz/corpus/alloc_ops/c26082c451e498b954b774c8c446a89261ad8a4c b/fuzz/corpus/alloc_ops/c26082c451e498b954b774c8c446a89261ad8a4c new file mode 100644 index 0000000..4f53dfc Binary files /dev/null and b/fuzz/corpus/alloc_ops/c26082c451e498b954b774c8c446a89261ad8a4c differ diff --git a/fuzz/corpus/alloc_ops/c27a142127a742ce649e22a7acde5af350c8f314 b/fuzz/corpus/alloc_ops/c27a142127a742ce649e22a7acde5af350c8f314 new file mode 100644 index 0000000..94b7911 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c27a142127a742ce649e22a7acde5af350c8f314 differ diff --git a/fuzz/corpus/alloc_ops/c2b2c65b0530f38d34b4ebac882812c0f4b0bdc3 b/fuzz/corpus/alloc_ops/c2b2c65b0530f38d34b4ebac882812c0f4b0bdc3 new file mode 100644 index 0000000..928ba45 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c2b2c65b0530f38d34b4ebac882812c0f4b0bdc3 differ diff --git a/fuzz/corpus/alloc_ops/c2e52302349a52955033351cb59e2d657fe6e350 b/fuzz/corpus/alloc_ops/c2e52302349a52955033351cb59e2d657fe6e350 new file mode 100644 index 0000000..73b6fd1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c2e52302349a52955033351cb59e2d657fe6e350 differ diff --git a/fuzz/corpus/alloc_ops/c2ed758f9afad91b260694b7aba9d14136d68b6d b/fuzz/corpus/alloc_ops/c2ed758f9afad91b260694b7aba9d14136d68b6d new file mode 100644 index 0000000..fda7b3b Binary files /dev/null and b/fuzz/corpus/alloc_ops/c2ed758f9afad91b260694b7aba9d14136d68b6d differ diff --git a/fuzz/corpus/alloc_ops/c3108ea85eaa6f99d94d632ecb21dc017929ceec b/fuzz/corpus/alloc_ops/c3108ea85eaa6f99d94d632ecb21dc017929ceec new file mode 100644 index 0000000..e698f7d Binary files /dev/null and b/fuzz/corpus/alloc_ops/c3108ea85eaa6f99d94d632ecb21dc017929ceec differ diff --git a/fuzz/corpus/alloc_ops/c346b17eba05d5252a040e2869b63997b7f1f32f b/fuzz/corpus/alloc_ops/c346b17eba05d5252a040e2869b63997b7f1f32f new file mode 100644 index 0000000..df79a20 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c346b17eba05d5252a040e2869b63997b7f1f32f differ diff --git a/fuzz/corpus/alloc_ops/c3475aa4517117df28c3f3650e2a342da4d0967e b/fuzz/corpus/alloc_ops/c3475aa4517117df28c3f3650e2a342da4d0967e new file mode 100644 index 0000000..8d716e9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c3475aa4517117df28c3f3650e2a342da4d0967e differ diff --git a/fuzz/corpus/alloc_ops/c36029377685d270828a7f0718f1eb9905fedcf1 b/fuzz/corpus/alloc_ops/c36029377685d270828a7f0718f1eb9905fedcf1 new file mode 100644 index 0000000..44922be Binary files /dev/null and b/fuzz/corpus/alloc_ops/c36029377685d270828a7f0718f1eb9905fedcf1 differ diff --git a/fuzz/corpus/alloc_ops/c3927cfadc41ac6feb0cc946698aaee657373e0e b/fuzz/corpus/alloc_ops/c3927cfadc41ac6feb0cc946698aaee657373e0e new file mode 100644 index 0000000..0eb99de Binary files /dev/null and b/fuzz/corpus/alloc_ops/c3927cfadc41ac6feb0cc946698aaee657373e0e differ diff --git a/fuzz/corpus/alloc_ops/c3939f95a8dbdcf748190a24be59dea6ab733810 b/fuzz/corpus/alloc_ops/c3939f95a8dbdcf748190a24be59dea6ab733810 new file mode 100644 index 0000000..2c195a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c3939f95a8dbdcf748190a24be59dea6ab733810 differ diff --git a/fuzz/corpus/alloc_ops/c3bf2a8c2a5d2e804f539721f7c4a2aab371ab22 b/fuzz/corpus/alloc_ops/c3bf2a8c2a5d2e804f539721f7c4a2aab371ab22 new file mode 100644 index 0000000..c8882de --- /dev/null +++ b/fuzz/corpus/alloc_ops/c3bf2a8c2a5d2e804f539721f7c4a2aab371ab22 @@ -0,0 +1 @@ +ÃÃÃÃÃÃÃ,ÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃà \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/c40fc83730386c94eabe5ccd2d98a64ac3751b4a b/fuzz/corpus/alloc_ops/c40fc83730386c94eabe5ccd2d98a64ac3751b4a new file mode 100644 index 0000000..8b368e9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c40fc83730386c94eabe5ccd2d98a64ac3751b4a differ diff --git a/fuzz/corpus/alloc_ops/c46abcd05ac6279a77b865a42b75e6f1ee69dc48 b/fuzz/corpus/alloc_ops/c46abcd05ac6279a77b865a42b75e6f1ee69dc48 new file mode 100644 index 0000000..a73b424 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c46abcd05ac6279a77b865a42b75e6f1ee69dc48 differ diff --git a/fuzz/corpus/alloc_ops/c4cb53ba7b14c8e8f0b843066147f11a35f5fd1a b/fuzz/corpus/alloc_ops/c4cb53ba7b14c8e8f0b843066147f11a35f5fd1a new file mode 100644 index 0000000..4852b4d Binary files /dev/null and b/fuzz/corpus/alloc_ops/c4cb53ba7b14c8e8f0b843066147f11a35f5fd1a differ diff --git a/fuzz/corpus/alloc_ops/c4cd85e411826297873bbb4417d6b55b3bbd7846 b/fuzz/corpus/alloc_ops/c4cd85e411826297873bbb4417d6b55b3bbd7846 new file mode 100644 index 0000000..f073765 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c4cd85e411826297873bbb4417d6b55b3bbd7846 differ diff --git a/fuzz/corpus/alloc_ops/c4fe94331bbb95643d0be4d71a441ffea404923c b/fuzz/corpus/alloc_ops/c4fe94331bbb95643d0be4d71a441ffea404923c new file mode 100644 index 0000000..831e155 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c4fe94331bbb95643d0be4d71a441ffea404923c differ diff --git a/fuzz/corpus/alloc_ops/c53f1e09ed3b6958f6725aefb5a182d1a2e959cd b/fuzz/corpus/alloc_ops/c53f1e09ed3b6958f6725aefb5a182d1a2e959cd new file mode 100644 index 0000000..614c707 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c53f1e09ed3b6958f6725aefb5a182d1a2e959cd differ diff --git a/fuzz/corpus/alloc_ops/c53faeaded5afef894af170fbd12ecd583844b9b b/fuzz/corpus/alloc_ops/c53faeaded5afef894af170fbd12ecd583844b9b new file mode 100644 index 0000000..0e87b99 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c53faeaded5afef894af170fbd12ecd583844b9b differ diff --git a/fuzz/corpus/alloc_ops/c55516e0bf69e2954cec831e36306507fd75c5ab b/fuzz/corpus/alloc_ops/c55516e0bf69e2954cec831e36306507fd75c5ab new file mode 100644 index 0000000..7648f4f Binary files /dev/null and b/fuzz/corpus/alloc_ops/c55516e0bf69e2954cec831e36306507fd75c5ab differ diff --git a/fuzz/corpus/alloc_ops/c58f68a3e57059b43b310c527affceb90acdcfed b/fuzz/corpus/alloc_ops/c58f68a3e57059b43b310c527affceb90acdcfed new file mode 100644 index 0000000..72e798b Binary files /dev/null and b/fuzz/corpus/alloc_ops/c58f68a3e57059b43b310c527affceb90acdcfed differ diff --git a/fuzz/corpus/alloc_ops/c5d0c95226dde87a1df3c69351ee022ba0778519 b/fuzz/corpus/alloc_ops/c5d0c95226dde87a1df3c69351ee022ba0778519 new file mode 100644 index 0000000..04a3762 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c5d0c95226dde87a1df3c69351ee022ba0778519 differ diff --git a/fuzz/corpus/alloc_ops/c5fec423d8341a19f59ac519213a83b7ba97a8a0 b/fuzz/corpus/alloc_ops/c5fec423d8341a19f59ac519213a83b7ba97a8a0 new file mode 100644 index 0000000..3bb7073 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c5fec423d8341a19f59ac519213a83b7ba97a8a0 differ diff --git a/fuzz/corpus/alloc_ops/c66e43accc22065c493c4c62debf247873c5d476 b/fuzz/corpus/alloc_ops/c66e43accc22065c493c4c62debf247873c5d476 new file mode 100644 index 0000000..3d7b815 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c66e43accc22065c493c4c62debf247873c5d476 differ diff --git a/fuzz/corpus/alloc_ops/c6e5496e13650ffe8140fb26a7f771cc031f7f33 b/fuzz/corpus/alloc_ops/c6e5496e13650ffe8140fb26a7f771cc031f7f33 new file mode 100644 index 0000000..15b7ee6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c6e5496e13650ffe8140fb26a7f771cc031f7f33 differ diff --git a/fuzz/corpus/alloc_ops/c6ec7b22271efd1d8658faef820d4cc1595cffec b/fuzz/corpus/alloc_ops/c6ec7b22271efd1d8658faef820d4cc1595cffec new file mode 100644 index 0000000..be0a217 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c6ec7b22271efd1d8658faef820d4cc1595cffec differ diff --git a/fuzz/corpus/alloc_ops/c6f1b96e5c7c2270f6ac2ce34ecc92a97f724ced b/fuzz/corpus/alloc_ops/c6f1b96e5c7c2270f6ac2ce34ecc92a97f724ced new file mode 100644 index 0000000..155c43f Binary files /dev/null and b/fuzz/corpus/alloc_ops/c6f1b96e5c7c2270f6ac2ce34ecc92a97f724ced differ diff --git a/fuzz/corpus/alloc_ops/c73dbd3d45fbe5768437523950de8c16b6946574 b/fuzz/corpus/alloc_ops/c73dbd3d45fbe5768437523950de8c16b6946574 new file mode 100644 index 0000000..b49bcc4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c73dbd3d45fbe5768437523950de8c16b6946574 differ diff --git a/fuzz/corpus/alloc_ops/c743006d98de31d710a899fb22420328a98c4a46 b/fuzz/corpus/alloc_ops/c743006d98de31d710a899fb22420328a98c4a46 new file mode 100644 index 0000000..afc2ece Binary files /dev/null and b/fuzz/corpus/alloc_ops/c743006d98de31d710a899fb22420328a98c4a46 differ diff --git a/fuzz/corpus/alloc_ops/c78b98ce489ae4fc26d73f95a8a068a3c84c9fca b/fuzz/corpus/alloc_ops/c78b98ce489ae4fc26d73f95a8a068a3c84c9fca new file mode 100644 index 0000000..abd5615 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c78b98ce489ae4fc26d73f95a8a068a3c84c9fca differ diff --git a/fuzz/corpus/alloc_ops/c78df993a923522be44001a2aff748e94eb3a451 b/fuzz/corpus/alloc_ops/c78df993a923522be44001a2aff748e94eb3a451 new file mode 100644 index 0000000..49df2ee Binary files /dev/null and b/fuzz/corpus/alloc_ops/c78df993a923522be44001a2aff748e94eb3a451 differ diff --git a/fuzz/corpus/alloc_ops/c79e23d3483faf0b1fbb154cbb856960f11dbc37 b/fuzz/corpus/alloc_ops/c79e23d3483faf0b1fbb154cbb856960f11dbc37 new file mode 100644 index 0000000..67cb907 --- /dev/null +++ b/fuzz/corpus/alloc_ops/c79e23d3483faf0b1fbb154cbb856960f11dbc37 @@ -0,0 +1 @@ +ÿ,ýÉÿýÿýzh) \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/c7a0c4a34e61b68f9cbe86ec86cb056e9edf7ab1 b/fuzz/corpus/alloc_ops/c7a0c4a34e61b68f9cbe86ec86cb056e9edf7ab1 new file mode 100644 index 0000000..8600f2b Binary files /dev/null and b/fuzz/corpus/alloc_ops/c7a0c4a34e61b68f9cbe86ec86cb056e9edf7ab1 differ diff --git a/fuzz/corpus/alloc_ops/c7a1ac00ca777030690a872259657a8221cb865c b/fuzz/corpus/alloc_ops/c7a1ac00ca777030690a872259657a8221cb865c new file mode 100644 index 0000000..2848b86 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c7a1ac00ca777030690a872259657a8221cb865c differ diff --git a/fuzz/corpus/alloc_ops/c7e62b3afbd48d5df14fa2fe93e6862c54a20537 b/fuzz/corpus/alloc_ops/c7e62b3afbd48d5df14fa2fe93e6862c54a20537 new file mode 100644 index 0000000..ced5434 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c7e62b3afbd48d5df14fa2fe93e6862c54a20537 differ diff --git a/fuzz/corpus/alloc_ops/c7ed182799e90e712fe348df62c663f38d690fb9 b/fuzz/corpus/alloc_ops/c7ed182799e90e712fe348df62c663f38d690fb9 new file mode 100644 index 0000000..2d5d2d9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c7ed182799e90e712fe348df62c663f38d690fb9 differ diff --git a/fuzz/corpus/alloc_ops/c7fda921938aa594ae8cde605f2e311c11a48bbd b/fuzz/corpus/alloc_ops/c7fda921938aa594ae8cde605f2e311c11a48bbd new file mode 100644 index 0000000..c5b6cdc Binary files /dev/null and b/fuzz/corpus/alloc_ops/c7fda921938aa594ae8cde605f2e311c11a48bbd differ diff --git a/fuzz/corpus/alloc_ops/c8409bde5d45b9ca743f515529b1dd54cf557685 b/fuzz/corpus/alloc_ops/c8409bde5d45b9ca743f515529b1dd54cf557685 new file mode 100644 index 0000000..5c4fbf5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c8409bde5d45b9ca743f515529b1dd54cf557685 differ diff --git a/fuzz/corpus/alloc_ops/c840a408438d733f7197bd1e4021adc78b6a233e b/fuzz/corpus/alloc_ops/c840a408438d733f7197bd1e4021adc78b6a233e new file mode 100644 index 0000000..34e99bd Binary files /dev/null and b/fuzz/corpus/alloc_ops/c840a408438d733f7197bd1e4021adc78b6a233e differ diff --git a/fuzz/corpus/alloc_ops/c84567ce95e5d85c8b7a8bff49d648ce80a0d82b b/fuzz/corpus/alloc_ops/c84567ce95e5d85c8b7a8bff49d648ce80a0d82b new file mode 100644 index 0000000..f918c00 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c84567ce95e5d85c8b7a8bff49d648ce80a0d82b differ diff --git a/fuzz/corpus/alloc_ops/c84c8bbfa5b9bbeffc83ef851180cd70838b0db6 b/fuzz/corpus/alloc_ops/c84c8bbfa5b9bbeffc83ef851180cd70838b0db6 new file mode 100644 index 0000000..2d180cb Binary files /dev/null and b/fuzz/corpus/alloc_ops/c84c8bbfa5b9bbeffc83ef851180cd70838b0db6 differ diff --git a/fuzz/corpus/alloc_ops/c891f46e09fe9c6b543033ff4351f1dce8546b2c b/fuzz/corpus/alloc_ops/c891f46e09fe9c6b543033ff4351f1dce8546b2c new file mode 100644 index 0000000..77e53fb Binary files /dev/null and b/fuzz/corpus/alloc_ops/c891f46e09fe9c6b543033ff4351f1dce8546b2c differ diff --git a/fuzz/corpus/alloc_ops/c89e75abaa19e0ad00d881c6660ab62996e5a23a b/fuzz/corpus/alloc_ops/c89e75abaa19e0ad00d881c6660ab62996e5a23a new file mode 100644 index 0000000..78844eb Binary files /dev/null and b/fuzz/corpus/alloc_ops/c89e75abaa19e0ad00d881c6660ab62996e5a23a differ diff --git a/fuzz/corpus/alloc_ops/c8dcb45dfdf7a71325fc4f20e592c96ab5cf988c b/fuzz/corpus/alloc_ops/c8dcb45dfdf7a71325fc4f20e592c96ab5cf988c new file mode 100644 index 0000000..aed5784 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c8dcb45dfdf7a71325fc4f20e592c96ab5cf988c differ diff --git a/fuzz/corpus/alloc_ops/c92af2693ba16f53ea1e16e084839e3b0d84d657 b/fuzz/corpus/alloc_ops/c92af2693ba16f53ea1e16e084839e3b0d84d657 new file mode 100644 index 0000000..0ed5ece Binary files /dev/null and b/fuzz/corpus/alloc_ops/c92af2693ba16f53ea1e16e084839e3b0d84d657 differ diff --git a/fuzz/corpus/alloc_ops/c938634803ae27e10fdddea16d0634ab8d46bd5f b/fuzz/corpus/alloc_ops/c938634803ae27e10fdddea16d0634ab8d46bd5f new file mode 100644 index 0000000..d969c58 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c938634803ae27e10fdddea16d0634ab8d46bd5f differ diff --git a/fuzz/corpus/alloc_ops/c93976a99d26adbf59a3a420b4d63e7c5a835334 b/fuzz/corpus/alloc_ops/c93976a99d26adbf59a3a420b4d63e7c5a835334 new file mode 100644 index 0000000..1cb0c9d Binary files /dev/null and b/fuzz/corpus/alloc_ops/c93976a99d26adbf59a3a420b4d63e7c5a835334 differ diff --git a/fuzz/corpus/alloc_ops/c94a7b1ec1d6c09fffd8ec66be141879f4a01675 b/fuzz/corpus/alloc_ops/c94a7b1ec1d6c09fffd8ec66be141879f4a01675 new file mode 100644 index 0000000..03a5b00 Binary files /dev/null and b/fuzz/corpus/alloc_ops/c94a7b1ec1d6c09fffd8ec66be141879f4a01675 differ diff --git a/fuzz/corpus/alloc_ops/ca1cd3a7c5caff7f7d0fc62ac468dee3a66aa1bb b/fuzz/corpus/alloc_ops/ca1cd3a7c5caff7f7d0fc62ac468dee3a66aa1bb new file mode 100644 index 0000000..a508931 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ca1cd3a7c5caff7f7d0fc62ac468dee3a66aa1bb differ diff --git a/fuzz/corpus/alloc_ops/ca397756fa1e0007eb4b07e2e4f745c3becfb074 b/fuzz/corpus/alloc_ops/ca397756fa1e0007eb4b07e2e4f745c3becfb074 new file mode 100644 index 0000000..41b5abd Binary files /dev/null and b/fuzz/corpus/alloc_ops/ca397756fa1e0007eb4b07e2e4f745c3becfb074 differ diff --git a/fuzz/corpus/alloc_ops/ca7ad58c62bcf0c64fee29476b48e8478001a0a1 b/fuzz/corpus/alloc_ops/ca7ad58c62bcf0c64fee29476b48e8478001a0a1 new file mode 100644 index 0000000..1e30aeb Binary files /dev/null and b/fuzz/corpus/alloc_ops/ca7ad58c62bcf0c64fee29476b48e8478001a0a1 differ diff --git a/fuzz/corpus/alloc_ops/cacb9b21c7100bedeb858fd6b7967a49f72f3d8e b/fuzz/corpus/alloc_ops/cacb9b21c7100bedeb858fd6b7967a49f72f3d8e new file mode 100644 index 0000000..5ac00c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cacb9b21c7100bedeb858fd6b7967a49f72f3d8e differ diff --git a/fuzz/corpus/alloc_ops/cafea37adcb72ef605b275bc633041d6fc34738b b/fuzz/corpus/alloc_ops/cafea37adcb72ef605b275bc633041d6fc34738b new file mode 100644 index 0000000..7aa5350 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cafea37adcb72ef605b275bc633041d6fc34738b differ diff --git a/fuzz/corpus/alloc_ops/cb0e3b2a7ad2727fa87abc34da22cd163ba0d194 b/fuzz/corpus/alloc_ops/cb0e3b2a7ad2727fa87abc34da22cd163ba0d194 new file mode 100644 index 0000000..1bd98ed Binary files /dev/null and b/fuzz/corpus/alloc_ops/cb0e3b2a7ad2727fa87abc34da22cd163ba0d194 differ diff --git a/fuzz/corpus/alloc_ops/cb56cf0145ca730da3dcc02ea2f65874508de3ec b/fuzz/corpus/alloc_ops/cb56cf0145ca730da3dcc02ea2f65874508de3ec new file mode 100644 index 0000000..19a36a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cb56cf0145ca730da3dcc02ea2f65874508de3ec differ diff --git a/fuzz/corpus/alloc_ops/cb8bc7205d04e3b16efe6fe23f4c62ff4074b494 b/fuzz/corpus/alloc_ops/cb8bc7205d04e3b16efe6fe23f4c62ff4074b494 new file mode 100644 index 0000000..87b2152 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cb8bc7205d04e3b16efe6fe23f4c62ff4074b494 differ diff --git a/fuzz/corpus/alloc_ops/cbb7c1cd5ec6e84e0f198b2d748c81e580f13dea b/fuzz/corpus/alloc_ops/cbb7c1cd5ec6e84e0f198b2d748c81e580f13dea new file mode 100644 index 0000000..c039b19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cbb7c1cd5ec6e84e0f198b2d748c81e580f13dea differ diff --git a/fuzz/corpus/alloc_ops/cbc390d59cfc020f1350220c2acf52f52d94afdd b/fuzz/corpus/alloc_ops/cbc390d59cfc020f1350220c2acf52f52d94afdd new file mode 100644 index 0000000..ce66b0a Binary files /dev/null and b/fuzz/corpus/alloc_ops/cbc390d59cfc020f1350220c2acf52f52d94afdd differ diff --git a/fuzz/corpus/alloc_ops/cc103688cd649aa310f83924382df2aba1ae6060 b/fuzz/corpus/alloc_ops/cc103688cd649aa310f83924382df2aba1ae6060 new file mode 100644 index 0000000..2eb65b8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cc103688cd649aa310f83924382df2aba1ae6060 differ diff --git a/fuzz/corpus/alloc_ops/cc11f7b16d3234ca7c074fe00ec132d588d816cf b/fuzz/corpus/alloc_ops/cc11f7b16d3234ca7c074fe00ec132d588d816cf new file mode 100644 index 0000000..bf5c5f6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cc11f7b16d3234ca7c074fe00ec132d588d816cf differ diff --git a/fuzz/corpus/alloc_ops/cc3ac3a0062ff7bfd1b7a0fafb3db706fa42617b b/fuzz/corpus/alloc_ops/cc3ac3a0062ff7bfd1b7a0fafb3db706fa42617b new file mode 100644 index 0000000..21e8177 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cc3ac3a0062ff7bfd1b7a0fafb3db706fa42617b differ diff --git a/fuzz/corpus/alloc_ops/cc909a39ffe3d2d9e8429884dbd2cfd5a26bf12a b/fuzz/corpus/alloc_ops/cc909a39ffe3d2d9e8429884dbd2cfd5a26bf12a new file mode 100644 index 0000000..0af995e Binary files /dev/null and b/fuzz/corpus/alloc_ops/cc909a39ffe3d2d9e8429884dbd2cfd5a26bf12a differ diff --git a/fuzz/corpus/alloc_ops/cc981cb9098a8a9611ccb34393e84f21f38cac35 b/fuzz/corpus/alloc_ops/cc981cb9098a8a9611ccb34393e84f21f38cac35 new file mode 100644 index 0000000..bd0df6d Binary files /dev/null and b/fuzz/corpus/alloc_ops/cc981cb9098a8a9611ccb34393e84f21f38cac35 differ diff --git a/fuzz/corpus/alloc_ops/cccea58442ec256d06713cbd7cababa0e08f1d34 b/fuzz/corpus/alloc_ops/cccea58442ec256d06713cbd7cababa0e08f1d34 new file mode 100644 index 0000000..ea01588 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cccea58442ec256d06713cbd7cababa0e08f1d34 differ diff --git a/fuzz/corpus/alloc_ops/cd0a55c052b03d1de162fcf15bff99f2410b67a8 b/fuzz/corpus/alloc_ops/cd0a55c052b03d1de162fcf15bff99f2410b67a8 new file mode 100644 index 0000000..b76c589 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cd0a55c052b03d1de162fcf15bff99f2410b67a8 differ diff --git a/fuzz/corpus/alloc_ops/cd12214e3abfac22b042767080036d4f212bab65 b/fuzz/corpus/alloc_ops/cd12214e3abfac22b042767080036d4f212bab65 new file mode 100644 index 0000000..98be7c7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cd12214e3abfac22b042767080036d4f212bab65 differ diff --git a/fuzz/corpus/alloc_ops/cd214facec56088cd55cf0fc72b11509e091c75b b/fuzz/corpus/alloc_ops/cd214facec56088cd55cf0fc72b11509e091c75b new file mode 100644 index 0000000..a6da5b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cd214facec56088cd55cf0fc72b11509e091c75b differ diff --git a/fuzz/corpus/alloc_ops/cd31607729c0a7c9122543d9892a9504310d825d b/fuzz/corpus/alloc_ops/cd31607729c0a7c9122543d9892a9504310d825d new file mode 100644 index 0000000..8e72ee3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cd31607729c0a7c9122543d9892a9504310d825d differ diff --git a/fuzz/corpus/alloc_ops/cd6b14aac02e3b1cd0e5f4f90a6df4888ef9d897 b/fuzz/corpus/alloc_ops/cd6b14aac02e3b1cd0e5f4f90a6df4888ef9d897 new file mode 100644 index 0000000..5359820 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cd6b14aac02e3b1cd0e5f4f90a6df4888ef9d897 differ diff --git a/fuzz/corpus/alloc_ops/cdf1d090869dc015e89fde8de7fd57a170d0298c b/fuzz/corpus/alloc_ops/cdf1d090869dc015e89fde8de7fd57a170d0298c new file mode 100644 index 0000000..f60d129 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cdf1d090869dc015e89fde8de7fd57a170d0298c differ diff --git a/fuzz/corpus/alloc_ops/ce037a77334977957ab68434c5793ebfc1ccdfa3 b/fuzz/corpus/alloc_ops/ce037a77334977957ab68434c5793ebfc1ccdfa3 new file mode 100644 index 0000000..10b8e13 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ce037a77334977957ab68434c5793ebfc1ccdfa3 differ diff --git a/fuzz/corpus/alloc_ops/ce0c2c50d7ae661b36a382234634acdd26aaa2de b/fuzz/corpus/alloc_ops/ce0c2c50d7ae661b36a382234634acdd26aaa2de new file mode 100644 index 0000000..9260598 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ce0c2c50d7ae661b36a382234634acdd26aaa2de differ diff --git a/fuzz/corpus/alloc_ops/ce1555b946ca00b29125e8c78af13eab38337ba0 b/fuzz/corpus/alloc_ops/ce1555b946ca00b29125e8c78af13eab38337ba0 new file mode 100644 index 0000000..97a3e9f Binary files /dev/null and b/fuzz/corpus/alloc_ops/ce1555b946ca00b29125e8c78af13eab38337ba0 differ diff --git a/fuzz/corpus/alloc_ops/ce7d8bc31f6153f597c559fb7b0db632e9c0e333 b/fuzz/corpus/alloc_ops/ce7d8bc31f6153f597c559fb7b0db632e9c0e333 new file mode 100644 index 0000000..a4833ad Binary files /dev/null and b/fuzz/corpus/alloc_ops/ce7d8bc31f6153f597c559fb7b0db632e9c0e333 differ diff --git a/fuzz/corpus/alloc_ops/ce97e47264a85fb5425490556d8d92ac8c6ee5c6 b/fuzz/corpus/alloc_ops/ce97e47264a85fb5425490556d8d92ac8c6ee5c6 new file mode 100644 index 0000000..85bdb6a Binary files /dev/null and b/fuzz/corpus/alloc_ops/ce97e47264a85fb5425490556d8d92ac8c6ee5c6 differ diff --git a/fuzz/corpus/alloc_ops/ceaedf10ac6c173204e66c0574dbad54c30b92a7 b/fuzz/corpus/alloc_ops/ceaedf10ac6c173204e66c0574dbad54c30b92a7 new file mode 100644 index 0000000..a909e5d Binary files /dev/null and b/fuzz/corpus/alloc_ops/ceaedf10ac6c173204e66c0574dbad54c30b92a7 differ diff --git a/fuzz/corpus/alloc_ops/ceed5ef046ee6cc63868406f54dfcc0648f6d49e b/fuzz/corpus/alloc_ops/ceed5ef046ee6cc63868406f54dfcc0648f6d49e new file mode 100644 index 0000000..84ebd1f Binary files /dev/null and b/fuzz/corpus/alloc_ops/ceed5ef046ee6cc63868406f54dfcc0648f6d49e differ diff --git a/fuzz/corpus/alloc_ops/cf014ae4cc88712b259bf4bd0c590430a9c203af b/fuzz/corpus/alloc_ops/cf014ae4cc88712b259bf4bd0c590430a9c203af new file mode 100644 index 0000000..4839684 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cf014ae4cc88712b259bf4bd0c590430a9c203af differ diff --git a/fuzz/corpus/alloc_ops/cf24a6c23eb8d99cea6bca60df4a35705951b07c b/fuzz/corpus/alloc_ops/cf24a6c23eb8d99cea6bca60df4a35705951b07c new file mode 100644 index 0000000..3278cb3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cf24a6c23eb8d99cea6bca60df4a35705951b07c differ diff --git a/fuzz/corpus/alloc_ops/cf2ee7bc9bbfbfec9b9b9c701dd03f2f7e2071eb b/fuzz/corpus/alloc_ops/cf2ee7bc9bbfbfec9b9b9c701dd03f2f7e2071eb new file mode 100644 index 0000000..9611fe6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cf2ee7bc9bbfbfec9b9b9c701dd03f2f7e2071eb differ diff --git a/fuzz/corpus/alloc_ops/cf53eb8792fc86b453a1fb20f1f33079c449409c b/fuzz/corpus/alloc_ops/cf53eb8792fc86b453a1fb20f1f33079c449409c new file mode 100644 index 0000000..357b568 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cf53eb8792fc86b453a1fb20f1f33079c449409c differ diff --git a/fuzz/corpus/alloc_ops/cf6864e7b850a7950fa65fac7fb6165441f90392 b/fuzz/corpus/alloc_ops/cf6864e7b850a7950fa65fac7fb6165441f90392 new file mode 100644 index 0000000..987e553 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cf6864e7b850a7950fa65fac7fb6165441f90392 differ diff --git a/fuzz/corpus/alloc_ops/cfbe30e207107a004da2cc018d12e7e39a8647be b/fuzz/corpus/alloc_ops/cfbe30e207107a004da2cc018d12e7e39a8647be new file mode 100644 index 0000000..8c233d4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/cfbe30e207107a004da2cc018d12e7e39a8647be differ diff --git a/fuzz/corpus/alloc_ops/d00fd9d9c3ebcd832e90f178e3f0dfd8b7e7978e b/fuzz/corpus/alloc_ops/d00fd9d9c3ebcd832e90f178e3f0dfd8b7e7978e new file mode 100644 index 0000000..91dd9a3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d00fd9d9c3ebcd832e90f178e3f0dfd8b7e7978e differ diff --git a/fuzz/corpus/alloc_ops/d01f6416177b40b374495e6900347f6ee3eca0a0 b/fuzz/corpus/alloc_ops/d01f6416177b40b374495e6900347f6ee3eca0a0 new file mode 100644 index 0000000..8c70b13 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d01f6416177b40b374495e6900347f6ee3eca0a0 differ diff --git a/fuzz/corpus/alloc_ops/d0260142003b669758965d5afaabde03275bfc65 b/fuzz/corpus/alloc_ops/d0260142003b669758965d5afaabde03275bfc65 new file mode 100644 index 0000000..2ce07d2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d0260142003b669758965d5afaabde03275bfc65 differ diff --git a/fuzz/corpus/alloc_ops/d093ecada55cb3af4c123b8589fc5abc66a980b4 b/fuzz/corpus/alloc_ops/d093ecada55cb3af4c123b8589fc5abc66a980b4 new file mode 100644 index 0000000..858af83 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d093ecada55cb3af4c123b8589fc5abc66a980b4 differ diff --git a/fuzz/corpus/alloc_ops/d0a92afb181be694c8cbb7a3c29478bd1ef58964 b/fuzz/corpus/alloc_ops/d0a92afb181be694c8cbb7a3c29478bd1ef58964 new file mode 100644 index 0000000..9679a82 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d0a92afb181be694c8cbb7a3c29478bd1ef58964 differ diff --git a/fuzz/corpus/alloc_ops/d0bb5d1e1f75c773912f2a60a3607be6ad243668 b/fuzz/corpus/alloc_ops/d0bb5d1e1f75c773912f2a60a3607be6ad243668 new file mode 100644 index 0000000..f942d8b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d0bb5d1e1f75c773912f2a60a3607be6ad243668 differ diff --git a/fuzz/corpus/alloc_ops/d0d872645dac65f3c91efc7487168cc576419876 b/fuzz/corpus/alloc_ops/d0d872645dac65f3c91efc7487168cc576419876 new file mode 100644 index 0000000..df804e9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d0d872645dac65f3c91efc7487168cc576419876 differ diff --git a/fuzz/corpus/alloc_ops/d0e5660f093562e20c11b87822f5d4813ca7955d b/fuzz/corpus/alloc_ops/d0e5660f093562e20c11b87822f5d4813ca7955d new file mode 100644 index 0000000..f0b9b91 --- /dev/null +++ b/fuzz/corpus/alloc_ops/d0e5660f093562e20c11b87822f5d4813ca7955d @@ -0,0 +1 @@ +—h@— \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/d12ae80f94d6de91a4d7c41915e893285417ce4c b/fuzz/corpus/alloc_ops/d12ae80f94d6de91a4d7c41915e893285417ce4c new file mode 100644 index 0000000..50099f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d12ae80f94d6de91a4d7c41915e893285417ce4c differ diff --git a/fuzz/corpus/alloc_ops/d134f8d1b95fb50ef6289b9f96b2fdd2da2e527c b/fuzz/corpus/alloc_ops/d134f8d1b95fb50ef6289b9f96b2fdd2da2e527c new file mode 100644 index 0000000..4fc8432 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d134f8d1b95fb50ef6289b9f96b2fdd2da2e527c differ diff --git a/fuzz/corpus/alloc_ops/d185ceea05fce6dd2c41007b9a17f68859f06214 b/fuzz/corpus/alloc_ops/d185ceea05fce6dd2c41007b9a17f68859f06214 new file mode 100644 index 0000000..5ff7c0a Binary files /dev/null and b/fuzz/corpus/alloc_ops/d185ceea05fce6dd2c41007b9a17f68859f06214 differ diff --git a/fuzz/corpus/alloc_ops/d223d3be46e576d5b9bca336f79ca78607f9a87f b/fuzz/corpus/alloc_ops/d223d3be46e576d5b9bca336f79ca78607f9a87f new file mode 100644 index 0000000..aa6f77d Binary files /dev/null and b/fuzz/corpus/alloc_ops/d223d3be46e576d5b9bca336f79ca78607f9a87f differ diff --git a/fuzz/corpus/alloc_ops/d2410936295ec47a3fa261d2859a2925451ed106 b/fuzz/corpus/alloc_ops/d2410936295ec47a3fa261d2859a2925451ed106 new file mode 100644 index 0000000..ca3d7c4 --- /dev/null +++ b/fuzz/corpus/alloc_ops/d2410936295ec47a3fa261d2859a2925451ed106 @@ -0,0 +1 @@ +öZZZ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/d28296a308bbf2d3616eb261c0d943cf40f1e3df b/fuzz/corpus/alloc_ops/d28296a308bbf2d3616eb261c0d943cf40f1e3df new file mode 100644 index 0000000..b154ef7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d28296a308bbf2d3616eb261c0d943cf40f1e3df differ diff --git a/fuzz/corpus/alloc_ops/d2834670bde5021e2ae175dfeb73764b7ef8716b b/fuzz/corpus/alloc_ops/d2834670bde5021e2ae175dfeb73764b7ef8716b new file mode 100644 index 0000000..0d7a175 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2834670bde5021e2ae175dfeb73764b7ef8716b differ diff --git a/fuzz/corpus/alloc_ops/d288d0c7cc9c99f532db8f9b2d69161a13893f84 b/fuzz/corpus/alloc_ops/d288d0c7cc9c99f532db8f9b2d69161a13893f84 new file mode 100644 index 0000000..ec2bf76 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d288d0c7cc9c99f532db8f9b2d69161a13893f84 differ diff --git a/fuzz/corpus/alloc_ops/d2aa36f60246c9b45e812cc774614f0559bfb6c4 b/fuzz/corpus/alloc_ops/d2aa36f60246c9b45e812cc774614f0559bfb6c4 new file mode 100644 index 0000000..d56b4bb Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2aa36f60246c9b45e812cc774614f0559bfb6c4 differ diff --git a/fuzz/corpus/alloc_ops/d2ad8f3abbd07894ca4d33db02df1b31bc65fdd4 b/fuzz/corpus/alloc_ops/d2ad8f3abbd07894ca4d33db02df1b31bc65fdd4 new file mode 100644 index 0000000..3396cd7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2ad8f3abbd07894ca4d33db02df1b31bc65fdd4 differ diff --git a/fuzz/corpus/alloc_ops/d2adde22bbfea824e84ab05f0fdb9240aa370b36 b/fuzz/corpus/alloc_ops/d2adde22bbfea824e84ab05f0fdb9240aa370b36 new file mode 100644 index 0000000..860ba19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2adde22bbfea824e84ab05f0fdb9240aa370b36 differ diff --git a/fuzz/corpus/alloc_ops/d2bdc077e944faf00b668ede654a8e7e94e6d214 b/fuzz/corpus/alloc_ops/d2bdc077e944faf00b668ede654a8e7e94e6d214 new file mode 100644 index 0000000..6d1ea60 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2bdc077e944faf00b668ede654a8e7e94e6d214 differ diff --git a/fuzz/corpus/alloc_ops/d2ced33e6df8071ec2c3e72189dc520218638bfe b/fuzz/corpus/alloc_ops/d2ced33e6df8071ec2c3e72189dc520218638bfe new file mode 100644 index 0000000..6aa3646 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2ced33e6df8071ec2c3e72189dc520218638bfe differ diff --git a/fuzz/corpus/alloc_ops/d2e147620f21c8ba519cc1d3e5c63807f64a38d9 b/fuzz/corpus/alloc_ops/d2e147620f21c8ba519cc1d3e5c63807f64a38d9 new file mode 100644 index 0000000..f86b2cf Binary files /dev/null and b/fuzz/corpus/alloc_ops/d2e147620f21c8ba519cc1d3e5c63807f64a38d9 differ diff --git a/fuzz/corpus/alloc_ops/d2ef7c7aa23147b6c0dfe47835fadfcedf762947 b/fuzz/corpus/alloc_ops/d2ef7c7aa23147b6c0dfe47835fadfcedf762947 new file mode 100644 index 0000000..07ba15e --- /dev/null +++ b/fuzz/corpus/alloc_ops/d2ef7c7aa23147b6c0dfe47835fadfcedf762947 @@ -0,0 +1 @@ +öZZZö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/d307f6b6048d09640d00f5f1014dd16b6990bc87 b/fuzz/corpus/alloc_ops/d307f6b6048d09640d00f5f1014dd16b6990bc87 new file mode 100644 index 0000000..4b00ff1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d307f6b6048d09640d00f5f1014dd16b6990bc87 differ diff --git a/fuzz/corpus/alloc_ops/d3534a869c337b1951f5b47aefc24282a5c45422 b/fuzz/corpus/alloc_ops/d3534a869c337b1951f5b47aefc24282a5c45422 new file mode 100644 index 0000000..45cd60b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d3534a869c337b1951f5b47aefc24282a5c45422 differ diff --git a/fuzz/corpus/alloc_ops/d35612ec8e917ab286b3485999460cedd9616ad6 b/fuzz/corpus/alloc_ops/d35612ec8e917ab286b3485999460cedd9616ad6 new file mode 100644 index 0000000..2ea5c51 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d35612ec8e917ab286b3485999460cedd9616ad6 differ diff --git a/fuzz/corpus/alloc_ops/d3713988f95defbe3af636c8b68be130fae0c767 b/fuzz/corpus/alloc_ops/d3713988f95defbe3af636c8b68be130fae0c767 new file mode 100644 index 0000000..ef9ffe4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d3713988f95defbe3af636c8b68be130fae0c767 differ diff --git a/fuzz/corpus/alloc_ops/d38296a1921037d279121b478724ae2d9d3678a0 b/fuzz/corpus/alloc_ops/d38296a1921037d279121b478724ae2d9d3678a0 new file mode 100644 index 0000000..591d7cd --- /dev/null +++ b/fuzz/corpus/alloc_ops/d38296a1921037d279121b478724ae2d9d3678a0 @@ -0,0 +1 @@ +—h— \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/d405cf5e107ccd47d6e0c475af499593fcdfdbf5 b/fuzz/corpus/alloc_ops/d405cf5e107ccd47d6e0c475af499593fcdfdbf5 new file mode 100644 index 0000000..666656e Binary files /dev/null and b/fuzz/corpus/alloc_ops/d405cf5e107ccd47d6e0c475af499593fcdfdbf5 differ diff --git a/fuzz/corpus/alloc_ops/d40eef84ce2935c0a3fa23d3e6195602fd970c25 b/fuzz/corpus/alloc_ops/d40eef84ce2935c0a3fa23d3e6195602fd970c25 new file mode 100644 index 0000000..af0778c Binary files /dev/null and b/fuzz/corpus/alloc_ops/d40eef84ce2935c0a3fa23d3e6195602fd970c25 differ diff --git a/fuzz/corpus/alloc_ops/d412843c78930776ef0887221a436e0637fcc2d1 b/fuzz/corpus/alloc_ops/d412843c78930776ef0887221a436e0637fcc2d1 new file mode 100644 index 0000000..33ab92d Binary files /dev/null and b/fuzz/corpus/alloc_ops/d412843c78930776ef0887221a436e0637fcc2d1 differ diff --git a/fuzz/corpus/alloc_ops/d4154b5c5888f4b583fe83b2d4a7c8310afa72de b/fuzz/corpus/alloc_ops/d4154b5c5888f4b583fe83b2d4a7c8310afa72de new file mode 100644 index 0000000..f09b242 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d4154b5c5888f4b583fe83b2d4a7c8310afa72de differ diff --git a/fuzz/corpus/alloc_ops/d42f8147bff6242939ca4e647eb23284d75c06a4 b/fuzz/corpus/alloc_ops/d42f8147bff6242939ca4e647eb23284d75c06a4 new file mode 100644 index 0000000..b88041b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d42f8147bff6242939ca4e647eb23284d75c06a4 differ diff --git a/fuzz/corpus/alloc_ops/d435812ee3733809eaaf43f283ded8f948f32514 b/fuzz/corpus/alloc_ops/d435812ee3733809eaaf43f283ded8f948f32514 new file mode 100644 index 0000000..d068f38 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d435812ee3733809eaaf43f283ded8f948f32514 differ diff --git a/fuzz/corpus/alloc_ops/d445afd38a56d6df5f87595977aed4bcbf70559c b/fuzz/corpus/alloc_ops/d445afd38a56d6df5f87595977aed4bcbf70559c new file mode 100644 index 0000000..c902b9b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d445afd38a56d6df5f87595977aed4bcbf70559c differ diff --git a/fuzz/corpus/alloc_ops/d44b3d661d004c0ac8edaf87a20aec49b8f2a193 b/fuzz/corpus/alloc_ops/d44b3d661d004c0ac8edaf87a20aec49b8f2a193 new file mode 100644 index 0000000..d61519e Binary files /dev/null and b/fuzz/corpus/alloc_ops/d44b3d661d004c0ac8edaf87a20aec49b8f2a193 differ diff --git a/fuzz/corpus/alloc_ops/d4929a92099bf9973c84d3bba1d30dd621a41204 b/fuzz/corpus/alloc_ops/d4929a92099bf9973c84d3bba1d30dd621a41204 new file mode 100644 index 0000000..2734c07 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d4929a92099bf9973c84d3bba1d30dd621a41204 differ diff --git a/fuzz/corpus/alloc_ops/d4b4d50548e5555b8444eda7e74dc0d32ecc5c02 b/fuzz/corpus/alloc_ops/d4b4d50548e5555b8444eda7e74dc0d32ecc5c02 new file mode 100644 index 0000000..15c0488 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d4b4d50548e5555b8444eda7e74dc0d32ecc5c02 differ diff --git a/fuzz/corpus/alloc_ops/d4cb6c88f3f56e96426935736065f9240ffab2ca b/fuzz/corpus/alloc_ops/d4cb6c88f3f56e96426935736065f9240ffab2ca new file mode 100644 index 0000000..14d375b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d4cb6c88f3f56e96426935736065f9240ffab2ca differ diff --git a/fuzz/corpus/alloc_ops/d54edf6c88ba6b3a324ef25606e8de75335527ae b/fuzz/corpus/alloc_ops/d54edf6c88ba6b3a324ef25606e8de75335527ae new file mode 100644 index 0000000..bc7c167 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d54edf6c88ba6b3a324ef25606e8de75335527ae differ diff --git a/fuzz/corpus/alloc_ops/d5b92d77b597b69bafbfaa918eccc460cfab31b7 b/fuzz/corpus/alloc_ops/d5b92d77b597b69bafbfaa918eccc460cfab31b7 new file mode 100644 index 0000000..efdb45b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d5b92d77b597b69bafbfaa918eccc460cfab31b7 differ diff --git a/fuzz/corpus/alloc_ops/d5dff9ac88a538d3afdc695a0da6def40342ed25 b/fuzz/corpus/alloc_ops/d5dff9ac88a538d3afdc695a0da6def40342ed25 new file mode 100644 index 0000000..69072d7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d5dff9ac88a538d3afdc695a0da6def40342ed25 differ diff --git a/fuzz/corpus/alloc_ops/d693b9be45f3fdd717c1c520e6092094f726e724 b/fuzz/corpus/alloc_ops/d693b9be45f3fdd717c1c520e6092094f726e724 new file mode 100644 index 0000000..0576709 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d693b9be45f3fdd717c1c520e6092094f726e724 differ diff --git a/fuzz/corpus/alloc_ops/d6c57ea76911bba8319df37a3ec714557462ce8e b/fuzz/corpus/alloc_ops/d6c57ea76911bba8319df37a3ec714557462ce8e new file mode 100644 index 0000000..7e9c788 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d6c57ea76911bba8319df37a3ec714557462ce8e differ diff --git a/fuzz/corpus/alloc_ops/d6c6b6e0bdb33cb7513b46fcbdf3a1ed2aae5eb0 b/fuzz/corpus/alloc_ops/d6c6b6e0bdb33cb7513b46fcbdf3a1ed2aae5eb0 new file mode 100644 index 0000000..6e8acb6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d6c6b6e0bdb33cb7513b46fcbdf3a1ed2aae5eb0 differ diff --git a/fuzz/corpus/alloc_ops/d6df4a7983116f755ade54a98775c408fd57727e b/fuzz/corpus/alloc_ops/d6df4a7983116f755ade54a98775c408fd57727e new file mode 100644 index 0000000..6e30c9a Binary files /dev/null and b/fuzz/corpus/alloc_ops/d6df4a7983116f755ade54a98775c408fd57727e differ diff --git a/fuzz/corpus/alloc_ops/d6e0ae235d0102e9de0bf0ecf065ecc64f791357 b/fuzz/corpus/alloc_ops/d6e0ae235d0102e9de0bf0ecf065ecc64f791357 new file mode 100644 index 0000000..8eaddc0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d6e0ae235d0102e9de0bf0ecf065ecc64f791357 differ diff --git a/fuzz/corpus/alloc_ops/d6e291a974ac007dcd40665afce240b78783940d b/fuzz/corpus/alloc_ops/d6e291a974ac007dcd40665afce240b78783940d new file mode 100644 index 0000000..28733d1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d6e291a974ac007dcd40665afce240b78783940d differ diff --git a/fuzz/corpus/alloc_ops/d7a55ef17be569aa54a2d6e06af308904bdc6005 b/fuzz/corpus/alloc_ops/d7a55ef17be569aa54a2d6e06af308904bdc6005 new file mode 100644 index 0000000..13360de Binary files /dev/null and b/fuzz/corpus/alloc_ops/d7a55ef17be569aa54a2d6e06af308904bdc6005 differ diff --git a/fuzz/corpus/alloc_ops/d7ad5a4cf93760793ab704b5d7be67ce1f286e1d b/fuzz/corpus/alloc_ops/d7ad5a4cf93760793ab704b5d7be67ce1f286e1d new file mode 100644 index 0000000..76b22cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/d7ad5a4cf93760793ab704b5d7be67ce1f286e1d differ diff --git a/fuzz/corpus/alloc_ops/d7ae6e0c3de4b2938f25909a2132ec82f554a57e b/fuzz/corpus/alloc_ops/d7ae6e0c3de4b2938f25909a2132ec82f554a57e new file mode 100644 index 0000000..066ac06 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d7ae6e0c3de4b2938f25909a2132ec82f554a57e differ diff --git a/fuzz/corpus/alloc_ops/d7d2d905ca6ac7a32a5fab7496a31fb0d3ece355 b/fuzz/corpus/alloc_ops/d7d2d905ca6ac7a32a5fab7496a31fb0d3ece355 new file mode 100644 index 0000000..69b6c94 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d7d2d905ca6ac7a32a5fab7496a31fb0d3ece355 differ diff --git a/fuzz/corpus/alloc_ops/d8373be2e3ae21ebfbf92192eac5d55a71032980 b/fuzz/corpus/alloc_ops/d8373be2e3ae21ebfbf92192eac5d55a71032980 new file mode 100644 index 0000000..3d131a2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d8373be2e3ae21ebfbf92192eac5d55a71032980 differ diff --git a/fuzz/corpus/alloc_ops/d853a0244f98db6bd81e0ded19364393f79b379c b/fuzz/corpus/alloc_ops/d853a0244f98db6bd81e0ded19364393f79b379c new file mode 100644 index 0000000..ceb7fe6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d853a0244f98db6bd81e0ded19364393f79b379c differ diff --git a/fuzz/corpus/alloc_ops/d8606de45040bec60b07fa7e6d513acbf0b17d94 b/fuzz/corpus/alloc_ops/d8606de45040bec60b07fa7e6d513acbf0b17d94 new file mode 100644 index 0000000..3e01e4f Binary files /dev/null and b/fuzz/corpus/alloc_ops/d8606de45040bec60b07fa7e6d513acbf0b17d94 differ diff --git a/fuzz/corpus/alloc_ops/d8674a396cb4cc9e25482f547b5221ea00f7d01f b/fuzz/corpus/alloc_ops/d8674a396cb4cc9e25482f547b5221ea00f7d01f new file mode 100644 index 0000000..0adc396 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d8674a396cb4cc9e25482f547b5221ea00f7d01f differ diff --git a/fuzz/corpus/alloc_ops/d86c1768424b46f6a2b18c34dd36f98273b4ee39 b/fuzz/corpus/alloc_ops/d86c1768424b46f6a2b18c34dd36f98273b4ee39 new file mode 100644 index 0000000..f27e0dc Binary files /dev/null and b/fuzz/corpus/alloc_ops/d86c1768424b46f6a2b18c34dd36f98273b4ee39 differ diff --git a/fuzz/corpus/alloc_ops/d86e2272f67dca47a56c2bf0834cc17d744d2445 b/fuzz/corpus/alloc_ops/d86e2272f67dca47a56c2bf0834cc17d744d2445 new file mode 100644 index 0000000..4b5726a Binary files /dev/null and b/fuzz/corpus/alloc_ops/d86e2272f67dca47a56c2bf0834cc17d744d2445 differ diff --git a/fuzz/corpus/alloc_ops/d8703b38cb8a1989994f54cf3c946d7462151587 b/fuzz/corpus/alloc_ops/d8703b38cb8a1989994f54cf3c946d7462151587 new file mode 100644 index 0000000..88b451f Binary files /dev/null and b/fuzz/corpus/alloc_ops/d8703b38cb8a1989994f54cf3c946d7462151587 differ diff --git a/fuzz/corpus/alloc_ops/d8fa4acba56769f96204c3c136aabc10e45e58e1 b/fuzz/corpus/alloc_ops/d8fa4acba56769f96204c3c136aabc10e45e58e1 new file mode 100644 index 0000000..c768caa Binary files /dev/null and b/fuzz/corpus/alloc_ops/d8fa4acba56769f96204c3c136aabc10e45e58e1 differ diff --git a/fuzz/corpus/alloc_ops/d92add2d39458df8f4913c998f8899a67527dcbc b/fuzz/corpus/alloc_ops/d92add2d39458df8f4913c998f8899a67527dcbc new file mode 100644 index 0000000..36f03b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d92add2d39458df8f4913c998f8899a67527dcbc differ diff --git a/fuzz/corpus/alloc_ops/d94b60c718b845d5ad41ebde3822be980c42fc11 b/fuzz/corpus/alloc_ops/d94b60c718b845d5ad41ebde3822be980c42fc11 new file mode 100644 index 0000000..8bca173 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d94b60c718b845d5ad41ebde3822be980c42fc11 differ diff --git a/fuzz/corpus/alloc_ops/d978ba57850797d28ebaca31046e694cbfc43c68 b/fuzz/corpus/alloc_ops/d978ba57850797d28ebaca31046e694cbfc43c68 new file mode 100644 index 0000000..865177b Binary files /dev/null and b/fuzz/corpus/alloc_ops/d978ba57850797d28ebaca31046e694cbfc43c68 differ diff --git a/fuzz/corpus/alloc_ops/d9a7ee4472b0f77e35c2e88ee8e4541afb708a6c b/fuzz/corpus/alloc_ops/d9a7ee4472b0f77e35c2e88ee8e4541afb708a6c new file mode 100644 index 0000000..231e694 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d9a7ee4472b0f77e35c2e88ee8e4541afb708a6c differ diff --git a/fuzz/corpus/alloc_ops/d9e206ed738a2e03e7326d6df4be657c2288caf7 b/fuzz/corpus/alloc_ops/d9e206ed738a2e03e7326d6df4be657c2288caf7 new file mode 100644 index 0000000..6263220 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d9e206ed738a2e03e7326d6df4be657c2288caf7 differ diff --git a/fuzz/corpus/alloc_ops/d9f3cb838d3db2e97d2be16b8c35cff28c1a4cdb b/fuzz/corpus/alloc_ops/d9f3cb838d3db2e97d2be16b8c35cff28c1a4cdb new file mode 100644 index 0000000..1657259 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d9f3cb838d3db2e97d2be16b8c35cff28c1a4cdb differ diff --git a/fuzz/corpus/alloc_ops/d9fc246bce548045106cfd9ef4ecbdd1a64c9658 b/fuzz/corpus/alloc_ops/d9fc246bce548045106cfd9ef4ecbdd1a64c9658 new file mode 100644 index 0000000..5685c65 Binary files /dev/null and b/fuzz/corpus/alloc_ops/d9fc246bce548045106cfd9ef4ecbdd1a64c9658 differ diff --git a/fuzz/corpus/alloc_ops/da00740f1d8c5abbff241ff4dfcdef1b91dc2c77 b/fuzz/corpus/alloc_ops/da00740f1d8c5abbff241ff4dfcdef1b91dc2c77 new file mode 100644 index 0000000..f6245e1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/da00740f1d8c5abbff241ff4dfcdef1b91dc2c77 differ diff --git a/fuzz/corpus/alloc_ops/da1b6a321f5ec9b7606728cfd3948456391c8f3e b/fuzz/corpus/alloc_ops/da1b6a321f5ec9b7606728cfd3948456391c8f3e new file mode 100644 index 0000000..1059f19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/da1b6a321f5ec9b7606728cfd3948456391c8f3e differ diff --git a/fuzz/corpus/alloc_ops/da1e99a12bcdd4c80b8f7de3f284bbce39965867 b/fuzz/corpus/alloc_ops/da1e99a12bcdd4c80b8f7de3f284bbce39965867 new file mode 100644 index 0000000..81b9d5a Binary files /dev/null and b/fuzz/corpus/alloc_ops/da1e99a12bcdd4c80b8f7de3f284bbce39965867 differ diff --git a/fuzz/corpus/alloc_ops/da4200b5d44a788b6d1b346934c29fc65a73d126 b/fuzz/corpus/alloc_ops/da4200b5d44a788b6d1b346934c29fc65a73d126 new file mode 100644 index 0000000..1f8e6de Binary files /dev/null and b/fuzz/corpus/alloc_ops/da4200b5d44a788b6d1b346934c29fc65a73d126 differ diff --git a/fuzz/corpus/alloc_ops/da6a02fb238853253e6d03f8afea3a982de49a49 b/fuzz/corpus/alloc_ops/da6a02fb238853253e6d03f8afea3a982de49a49 new file mode 100644 index 0000000..879bb0a Binary files /dev/null and b/fuzz/corpus/alloc_ops/da6a02fb238853253e6d03f8afea3a982de49a49 differ diff --git a/fuzz/corpus/alloc_ops/da7e7756bb3e453f5c5833c693c100cfaf995ae5 b/fuzz/corpus/alloc_ops/da7e7756bb3e453f5c5833c693c100cfaf995ae5 new file mode 100644 index 0000000..4476fbd Binary files /dev/null and b/fuzz/corpus/alloc_ops/da7e7756bb3e453f5c5833c693c100cfaf995ae5 differ diff --git a/fuzz/corpus/alloc_ops/dad95156d89ef0b630e33f6b0f80dd6e7fbe3093 b/fuzz/corpus/alloc_ops/dad95156d89ef0b630e33f6b0f80dd6e7fbe3093 new file mode 100644 index 0000000..9e8df68 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dad95156d89ef0b630e33f6b0f80dd6e7fbe3093 differ diff --git a/fuzz/corpus/alloc_ops/dae0fbdce08bb4f0531a9224f4b9aaeace466620 b/fuzz/corpus/alloc_ops/dae0fbdce08bb4f0531a9224f4b9aaeace466620 new file mode 100644 index 0000000..75e083a Binary files /dev/null and b/fuzz/corpus/alloc_ops/dae0fbdce08bb4f0531a9224f4b9aaeace466620 differ diff --git a/fuzz/corpus/alloc_ops/db073c6244bbb8ce5c60f34f46701626a68a5a48 b/fuzz/corpus/alloc_ops/db073c6244bbb8ce5c60f34f46701626a68a5a48 new file mode 100644 index 0000000..1858ddb Binary files /dev/null and b/fuzz/corpus/alloc_ops/db073c6244bbb8ce5c60f34f46701626a68a5a48 differ diff --git a/fuzz/corpus/alloc_ops/db65188fa887c55c496409ec3614aea3dc96e36f b/fuzz/corpus/alloc_ops/db65188fa887c55c496409ec3614aea3dc96e36f new file mode 100644 index 0000000..8aae844 Binary files /dev/null and b/fuzz/corpus/alloc_ops/db65188fa887c55c496409ec3614aea3dc96e36f differ diff --git a/fuzz/corpus/alloc_ops/dbb4ab04f3ea442695f52f698cda481a3110952b b/fuzz/corpus/alloc_ops/dbb4ab04f3ea442695f52f698cda481a3110952b new file mode 100644 index 0000000..21c9c92 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dbb4ab04f3ea442695f52f698cda481a3110952b differ diff --git a/fuzz/corpus/alloc_ops/dbde26611b50cfc70cc8914fd7acfd70a7bfc71a b/fuzz/corpus/alloc_ops/dbde26611b50cfc70cc8914fd7acfd70a7bfc71a new file mode 100644 index 0000000..20a6f8c Binary files /dev/null and b/fuzz/corpus/alloc_ops/dbde26611b50cfc70cc8914fd7acfd70a7bfc71a differ diff --git a/fuzz/corpus/alloc_ops/dbf3b54a1251b9fef77060bfba232d55d6b67cd1 b/fuzz/corpus/alloc_ops/dbf3b54a1251b9fef77060bfba232d55d6b67cd1 new file mode 100644 index 0000000..8fa120d Binary files /dev/null and b/fuzz/corpus/alloc_ops/dbf3b54a1251b9fef77060bfba232d55d6b67cd1 differ diff --git a/fuzz/corpus/alloc_ops/dbfbd78613ad403568e64724009d6adf8900ee5c b/fuzz/corpus/alloc_ops/dbfbd78613ad403568e64724009d6adf8900ee5c new file mode 100644 index 0000000..39b27fd Binary files /dev/null and b/fuzz/corpus/alloc_ops/dbfbd78613ad403568e64724009d6adf8900ee5c differ diff --git a/fuzz/corpus/alloc_ops/dc49b031e2970b24d506f71b25217f20cfc9ed2c b/fuzz/corpus/alloc_ops/dc49b031e2970b24d506f71b25217f20cfc9ed2c new file mode 100644 index 0000000..6403121 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dc49b031e2970b24d506f71b25217f20cfc9ed2c differ diff --git a/fuzz/corpus/alloc_ops/dc6f34b1942129367cb144ee8f4d11033af3f1a1 b/fuzz/corpus/alloc_ops/dc6f34b1942129367cb144ee8f4d11033af3f1a1 new file mode 100644 index 0000000..0311f9d Binary files /dev/null and b/fuzz/corpus/alloc_ops/dc6f34b1942129367cb144ee8f4d11033af3f1a1 differ diff --git a/fuzz/corpus/alloc_ops/dcee6b62affe0156febb519a23f917f12427bfcd b/fuzz/corpus/alloc_ops/dcee6b62affe0156febb519a23f917f12427bfcd new file mode 100644 index 0000000..6a88d26 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dcee6b62affe0156febb519a23f917f12427bfcd differ diff --git a/fuzz/corpus/alloc_ops/dd203ee3a3e9e116b7fa43df2f50c9dc91fca613 b/fuzz/corpus/alloc_ops/dd203ee3a3e9e116b7fa43df2f50c9dc91fca613 new file mode 100644 index 0000000..674fe2a Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd203ee3a3e9e116b7fa43df2f50c9dc91fca613 differ diff --git a/fuzz/corpus/alloc_ops/dd21918998edc828369307681fe0deb80b4bcc68 b/fuzz/corpus/alloc_ops/dd21918998edc828369307681fe0deb80b4bcc68 new file mode 100644 index 0000000..081abb8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd21918998edc828369307681fe0deb80b4bcc68 differ diff --git a/fuzz/corpus/alloc_ops/dd3ee4e9b220f779a1b494d60e48b6f10aac8a2a b/fuzz/corpus/alloc_ops/dd3ee4e9b220f779a1b494d60e48b6f10aac8a2a new file mode 100644 index 0000000..ffe03b8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd3ee4e9b220f779a1b494d60e48b6f10aac8a2a differ diff --git a/fuzz/corpus/alloc_ops/dd3ff647fdd442822acc4e70c89d2e9cff71218c b/fuzz/corpus/alloc_ops/dd3ff647fdd442822acc4e70c89d2e9cff71218c new file mode 100644 index 0000000..13c50c3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd3ff647fdd442822acc4e70c89d2e9cff71218c differ diff --git a/fuzz/corpus/alloc_ops/dd6e8307530b1478e5a87bade1984541f4811235 b/fuzz/corpus/alloc_ops/dd6e8307530b1478e5a87bade1984541f4811235 new file mode 100644 index 0000000..146ee27 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd6e8307530b1478e5a87bade1984541f4811235 differ diff --git a/fuzz/corpus/alloc_ops/dd8dde369234c953c3b5531a8eb3023bb45ccc92 b/fuzz/corpus/alloc_ops/dd8dde369234c953c3b5531a8eb3023bb45ccc92 new file mode 100644 index 0000000..58408ab Binary files /dev/null and b/fuzz/corpus/alloc_ops/dd8dde369234c953c3b5531a8eb3023bb45ccc92 differ diff --git a/fuzz/corpus/alloc_ops/ddb9ed448c561bac6c6885f4b8f4f6ce911952ef b/fuzz/corpus/alloc_ops/ddb9ed448c561bac6c6885f4b8f4f6ce911952ef new file mode 100644 index 0000000..659c737 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ddb9ed448c561bac6c6885f4b8f4f6ce911952ef differ diff --git a/fuzz/corpus/alloc_ops/ddcb2297a9bf86326ac759ccd52619ba1f12823e b/fuzz/corpus/alloc_ops/ddcb2297a9bf86326ac759ccd52619ba1f12823e new file mode 100644 index 0000000..b8d59ff Binary files /dev/null and b/fuzz/corpus/alloc_ops/ddcb2297a9bf86326ac759ccd52619ba1f12823e differ diff --git a/fuzz/corpus/alloc_ops/ddd8bccbb10152e594e1fa63e43f3da0159a290c b/fuzz/corpus/alloc_ops/ddd8bccbb10152e594e1fa63e43f3da0159a290c new file mode 100644 index 0000000..9262a92 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ddd8bccbb10152e594e1fa63e43f3da0159a290c differ diff --git a/fuzz/corpus/alloc_ops/dde69f45d9d3d36af58bf4ac20d0c6d91e404841 b/fuzz/corpus/alloc_ops/dde69f45d9d3d36af58bf4ac20d0c6d91e404841 new file mode 100644 index 0000000..39d84e6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dde69f45d9d3d36af58bf4ac20d0c6d91e404841 differ diff --git a/fuzz/corpus/alloc_ops/de318ba98fffbad9ee172a27334964a4abbb0511 b/fuzz/corpus/alloc_ops/de318ba98fffbad9ee172a27334964a4abbb0511 new file mode 100644 index 0000000..a6c286d --- /dev/null +++ b/fuzz/corpus/alloc_ops/de318ba98fffbad9ee172a27334964a4abbb0511 @@ -0,0 +1 @@ +þþµþþþþþþþþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/de3445d16a3279a33e48118053573bfa42321e12 b/fuzz/corpus/alloc_ops/de3445d16a3279a33e48118053573bfa42321e12 new file mode 100644 index 0000000..2b86c40 Binary files /dev/null and b/fuzz/corpus/alloc_ops/de3445d16a3279a33e48118053573bfa42321e12 differ diff --git a/fuzz/corpus/alloc_ops/de528155ae6dc37247cd4a5e9265cb5782287213 b/fuzz/corpus/alloc_ops/de528155ae6dc37247cd4a5e9265cb5782287213 new file mode 100644 index 0000000..b699dbe Binary files /dev/null and b/fuzz/corpus/alloc_ops/de528155ae6dc37247cd4a5e9265cb5782287213 differ diff --git a/fuzz/corpus/alloc_ops/de58f79b8c6aaf31d57333a6b04814879215e758 b/fuzz/corpus/alloc_ops/de58f79b8c6aaf31d57333a6b04814879215e758 new file mode 100644 index 0000000..b2caa69 Binary files /dev/null and b/fuzz/corpus/alloc_ops/de58f79b8c6aaf31d57333a6b04814879215e758 differ diff --git a/fuzz/corpus/alloc_ops/de5e4d7577f93c12c03c18bcf4e5832687010bb8 b/fuzz/corpus/alloc_ops/de5e4d7577f93c12c03c18bcf4e5832687010bb8 new file mode 100644 index 0000000..cd82c03 Binary files /dev/null and b/fuzz/corpus/alloc_ops/de5e4d7577f93c12c03c18bcf4e5832687010bb8 differ diff --git a/fuzz/corpus/alloc_ops/de6b4ed4a8a26da29194ee029ac415e6f0aa76e6 b/fuzz/corpus/alloc_ops/de6b4ed4a8a26da29194ee029ac415e6f0aa76e6 new file mode 100644 index 0000000..3be1ef8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/de6b4ed4a8a26da29194ee029ac415e6f0aa76e6 differ diff --git a/fuzz/corpus/alloc_ops/dea4aa7a4abb83e958a9ba9c4090d9840373602e b/fuzz/corpus/alloc_ops/dea4aa7a4abb83e958a9ba9c4090d9840373602e new file mode 100644 index 0000000..9462949 --- /dev/null +++ b/fuzz/corpus/alloc_ops/dea4aa7a4abb83e958a9ba9c4090d9840373602e @@ -0,0 +1 @@ +öööôöAööööö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/dee2ab1bc45d296393912286c62b27103c5502c2 b/fuzz/corpus/alloc_ops/dee2ab1bc45d296393912286c62b27103c5502c2 new file mode 100644 index 0000000..3ac7f2f Binary files /dev/null and b/fuzz/corpus/alloc_ops/dee2ab1bc45d296393912286c62b27103c5502c2 differ diff --git a/fuzz/corpus/alloc_ops/df378048ce383e457924d72dc19eb2885445d29d b/fuzz/corpus/alloc_ops/df378048ce383e457924d72dc19eb2885445d29d new file mode 100644 index 0000000..d7b75cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/df378048ce383e457924d72dc19eb2885445d29d differ diff --git a/fuzz/corpus/alloc_ops/df885a8a45bcc1d4f834724a1f8c935b9c95221f b/fuzz/corpus/alloc_ops/df885a8a45bcc1d4f834724a1f8c935b9c95221f new file mode 100644 index 0000000..08acd19 --- /dev/null +++ b/fuzz/corpus/alloc_ops/df885a8a45bcc1d4f834724a1f8c935b9c95221f @@ -0,0 +1 @@ +þþµþþþþþ'þþþþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/dfe2c729e170f27bb94d6247d0e75bf11153b47a b/fuzz/corpus/alloc_ops/dfe2c729e170f27bb94d6247d0e75bf11153b47a new file mode 100644 index 0000000..8b79056 Binary files /dev/null and b/fuzz/corpus/alloc_ops/dfe2c729e170f27bb94d6247d0e75bf11153b47a differ diff --git a/fuzz/corpus/alloc_ops/e0cab15435af922e8f17ca5efcfe1e83a0c45d0d b/fuzz/corpus/alloc_ops/e0cab15435af922e8f17ca5efcfe1e83a0c45d0d new file mode 100644 index 0000000..23001f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e0cab15435af922e8f17ca5efcfe1e83a0c45d0d differ diff --git a/fuzz/corpus/alloc_ops/e0e9227fedd8ca9cddb60f227cb35e6e4f7fffe0 b/fuzz/corpus/alloc_ops/e0e9227fedd8ca9cddb60f227cb35e6e4f7fffe0 new file mode 100644 index 0000000..85f1c8a Binary files /dev/null and b/fuzz/corpus/alloc_ops/e0e9227fedd8ca9cddb60f227cb35e6e4f7fffe0 differ diff --git a/fuzz/corpus/alloc_ops/e1047216309bad12c030247d9cfeb9a2e865f532 b/fuzz/corpus/alloc_ops/e1047216309bad12c030247d9cfeb9a2e865f532 new file mode 100644 index 0000000..c71375e Binary files /dev/null and b/fuzz/corpus/alloc_ops/e1047216309bad12c030247d9cfeb9a2e865f532 differ diff --git a/fuzz/corpus/alloc_ops/e11584ad546bfe206aad8cb1332732ece191a75e b/fuzz/corpus/alloc_ops/e11584ad546bfe206aad8cb1332732ece191a75e new file mode 100644 index 0000000..610cf80 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e11584ad546bfe206aad8cb1332732ece191a75e differ diff --git a/fuzz/corpus/alloc_ops/e124520c33e57382be78a378d0105f7ac40384b2 b/fuzz/corpus/alloc_ops/e124520c33e57382be78a378d0105f7ac40384b2 new file mode 100644 index 0000000..d01e957 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e124520c33e57382be78a378d0105f7ac40384b2 differ diff --git a/fuzz/corpus/alloc_ops/e16099b411e0ef63ecf5b9244595f83cf3c4c094 b/fuzz/corpus/alloc_ops/e16099b411e0ef63ecf5b9244595f83cf3c4c094 new file mode 100644 index 0000000..ff56ca1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e16099b411e0ef63ecf5b9244595f83cf3c4c094 differ diff --git a/fuzz/corpus/alloc_ops/e160e4cdd45f4ec755221429f9730d2d3e2a40dd b/fuzz/corpus/alloc_ops/e160e4cdd45f4ec755221429f9730d2d3e2a40dd new file mode 100644 index 0000000..18b5dc3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e160e4cdd45f4ec755221429f9730d2d3e2a40dd differ diff --git a/fuzz/corpus/alloc_ops/e160f88715c76101adb468451fcd056a59a46a6b b/fuzz/corpus/alloc_ops/e160f88715c76101adb468451fcd056a59a46a6b new file mode 100644 index 0000000..9dde6b4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e160f88715c76101adb468451fcd056a59a46a6b differ diff --git a/fuzz/corpus/alloc_ops/e18597b3084bdd4526105ad768a3c1d5867260f6 b/fuzz/corpus/alloc_ops/e18597b3084bdd4526105ad768a3c1d5867260f6 new file mode 100644 index 0000000..e8409da --- /dev/null +++ b/fuzz/corpus/alloc_ops/e18597b3084bdd4526105ad768a3c1d5867260f6 @@ -0,0 +1 @@ +þþþþþþþþþþþþþþþþþþþþþþþþþþþ;þþþþþþþþþþþþþþþþþþþþþþþ¤þþþþþþþþþÿÿþþ;þþþþþþþþKþþþÿ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/e1c3f43ff518524e35f9b1991472ea6e82ba6a9a b/fuzz/corpus/alloc_ops/e1c3f43ff518524e35f9b1991472ea6e82ba6a9a new file mode 100644 index 0000000..fd2d987 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e1c3f43ff518524e35f9b1991472ea6e82ba6a9a differ diff --git a/fuzz/corpus/alloc_ops/e282d2a1f282696f229f1d7d65323ca09cc40330 b/fuzz/corpus/alloc_ops/e282d2a1f282696f229f1d7d65323ca09cc40330 new file mode 100644 index 0000000..513b169 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e282d2a1f282696f229f1d7d65323ca09cc40330 differ diff --git a/fuzz/corpus/alloc_ops/e2aa9ded80ee56ca79d55101ff478a94b07bbd76 b/fuzz/corpus/alloc_ops/e2aa9ded80ee56ca79d55101ff478a94b07bbd76 new file mode 100644 index 0000000..df9cd53 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e2aa9ded80ee56ca79d55101ff478a94b07bbd76 differ diff --git a/fuzz/corpus/alloc_ops/e2ee03cc25c3d8ecec4c7933d55950ec8f39a922 b/fuzz/corpus/alloc_ops/e2ee03cc25c3d8ecec4c7933d55950ec8f39a922 new file mode 100644 index 0000000..dcbf2a3 --- /dev/null +++ b/fuzz/corpus/alloc_ops/e2ee03cc25c3d8ecec4c7933d55950ec8f39a922 @@ -0,0 +1 @@ +€ \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/e32f14fdc04a61e336acfeed3ffa385e041d987e b/fuzz/corpus/alloc_ops/e32f14fdc04a61e336acfeed3ffa385e041d987e new file mode 100644 index 0000000..8ed8ec8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e32f14fdc04a61e336acfeed3ffa385e041d987e differ diff --git a/fuzz/corpus/alloc_ops/e3314a4b0f6df08ded479acfecf7bdb50f42ef14 b/fuzz/corpus/alloc_ops/e3314a4b0f6df08ded479acfecf7bdb50f42ef14 new file mode 100644 index 0000000..e45256f Binary files /dev/null and b/fuzz/corpus/alloc_ops/e3314a4b0f6df08ded479acfecf7bdb50f42ef14 differ diff --git a/fuzz/corpus/alloc_ops/e347bd7c467c8d222ebfb8268a158d5b56264dae b/fuzz/corpus/alloc_ops/e347bd7c467c8d222ebfb8268a158d5b56264dae new file mode 100644 index 0000000..04cdad1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e347bd7c467c8d222ebfb8268a158d5b56264dae differ diff --git a/fuzz/corpus/alloc_ops/e34a308b8e7a4623544f8d410060ec177eded83e b/fuzz/corpus/alloc_ops/e34a308b8e7a4623544f8d410060ec177eded83e new file mode 100644 index 0000000..2a69ce7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e34a308b8e7a4623544f8d410060ec177eded83e differ diff --git a/fuzz/corpus/alloc_ops/e34fde89572000936613470074a1e4c3888091c3 b/fuzz/corpus/alloc_ops/e34fde89572000936613470074a1e4c3888091c3 new file mode 100644 index 0000000..8a846bf Binary files /dev/null and b/fuzz/corpus/alloc_ops/e34fde89572000936613470074a1e4c3888091c3 differ diff --git a/fuzz/corpus/alloc_ops/e373191c4848f16e22c0c42cb128e86a4b2c6d36 b/fuzz/corpus/alloc_ops/e373191c4848f16e22c0c42cb128e86a4b2c6d36 new file mode 100644 index 0000000..1317355 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e373191c4848f16e22c0c42cb128e86a4b2c6d36 differ diff --git a/fuzz/corpus/alloc_ops/e3bce201dcdf96fbc881d2810e6410f5daf963e7 b/fuzz/corpus/alloc_ops/e3bce201dcdf96fbc881d2810e6410f5daf963e7 new file mode 100644 index 0000000..a9a746a Binary files /dev/null and b/fuzz/corpus/alloc_ops/e3bce201dcdf96fbc881d2810e6410f5daf963e7 differ diff --git a/fuzz/corpus/alloc_ops/e42413047d1582af058acad6eb396c5100469eaa b/fuzz/corpus/alloc_ops/e42413047d1582af058acad6eb396c5100469eaa new file mode 100644 index 0000000..ea2b725 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e42413047d1582af058acad6eb396c5100469eaa differ diff --git a/fuzz/corpus/alloc_ops/e42684fe3bf5a871f5f00fb550d0ef572c087009 b/fuzz/corpus/alloc_ops/e42684fe3bf5a871f5f00fb550d0ef572c087009 new file mode 100644 index 0000000..42e8a15 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e42684fe3bf5a871f5f00fb550d0ef572c087009 differ diff --git a/fuzz/corpus/alloc_ops/e4789d6ffabaebe84710e4be7724bcf41a68ad48 b/fuzz/corpus/alloc_ops/e4789d6ffabaebe84710e4be7724bcf41a68ad48 new file mode 100644 index 0000000..1599678 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e4789d6ffabaebe84710e4be7724bcf41a68ad48 differ diff --git a/fuzz/corpus/alloc_ops/e4fbda7cbdd55bd295c62a4981aa76c43a90479f b/fuzz/corpus/alloc_ops/e4fbda7cbdd55bd295c62a4981aa76c43a90479f new file mode 100644 index 0000000..8b947e0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e4fbda7cbdd55bd295c62a4981aa76c43a90479f differ diff --git a/fuzz/corpus/alloc_ops/e54c96730c908f3466ca3d47a39a5972111ba711 b/fuzz/corpus/alloc_ops/e54c96730c908f3466ca3d47a39a5972111ba711 new file mode 100644 index 0000000..78c71b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e54c96730c908f3466ca3d47a39a5972111ba711 differ diff --git a/fuzz/corpus/alloc_ops/e54d9d25823c890ae0fc98aaf040902518f32d56 b/fuzz/corpus/alloc_ops/e54d9d25823c890ae0fc98aaf040902518f32d56 new file mode 100644 index 0000000..a79afd4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e54d9d25823c890ae0fc98aaf040902518f32d56 differ diff --git a/fuzz/corpus/alloc_ops/e56bb505c0034e5931912302186632d30a712d40 b/fuzz/corpus/alloc_ops/e56bb505c0034e5931912302186632d30a712d40 new file mode 100644 index 0000000..b4a7cd5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e56bb505c0034e5931912302186632d30a712d40 differ diff --git a/fuzz/corpus/alloc_ops/e582d94b347a3d8f52f54e5b82ff1181d89a4bb9 b/fuzz/corpus/alloc_ops/e582d94b347a3d8f52f54e5b82ff1181d89a4bb9 new file mode 100644 index 0000000..b4c8d88 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e582d94b347a3d8f52f54e5b82ff1181d89a4bb9 differ diff --git a/fuzz/corpus/alloc_ops/e588636f67aa14ebf024e5881d9bc91433834d0c b/fuzz/corpus/alloc_ops/e588636f67aa14ebf024e5881d9bc91433834d0c new file mode 100644 index 0000000..57e7cad Binary files /dev/null and b/fuzz/corpus/alloc_ops/e588636f67aa14ebf024e5881d9bc91433834d0c differ diff --git a/fuzz/corpus/alloc_ops/e5a0157855c759688a7a96f4f3105f51a414bb39 b/fuzz/corpus/alloc_ops/e5a0157855c759688a7a96f4f3105f51a414bb39 new file mode 100644 index 0000000..59f3dcf Binary files /dev/null and b/fuzz/corpus/alloc_ops/e5a0157855c759688a7a96f4f3105f51a414bb39 differ diff --git a/fuzz/corpus/alloc_ops/e65e8dad4f30df261a9a73de6f95ae3d58f27ea8 b/fuzz/corpus/alloc_ops/e65e8dad4f30df261a9a73de6f95ae3d58f27ea8 new file mode 100644 index 0000000..867eef5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e65e8dad4f30df261a9a73de6f95ae3d58f27ea8 differ diff --git a/fuzz/corpus/alloc_ops/e6993befa8cfc02b47d915df997ee478d433964f b/fuzz/corpus/alloc_ops/e6993befa8cfc02b47d915df997ee478d433964f new file mode 100644 index 0000000..9f166cf Binary files /dev/null and b/fuzz/corpus/alloc_ops/e6993befa8cfc02b47d915df997ee478d433964f differ diff --git a/fuzz/corpus/alloc_ops/e6b2fa7703c4323d9f31cfeaf871336163645a54 b/fuzz/corpus/alloc_ops/e6b2fa7703c4323d9f31cfeaf871336163645a54 new file mode 100644 index 0000000..4bcce69 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e6b2fa7703c4323d9f31cfeaf871336163645a54 differ diff --git a/fuzz/corpus/alloc_ops/e6b67e060d02d0291bcb62f019d5eec11c57c8ed b/fuzz/corpus/alloc_ops/e6b67e060d02d0291bcb62f019d5eec11c57c8ed new file mode 100644 index 0000000..30f812c Binary files /dev/null and b/fuzz/corpus/alloc_ops/e6b67e060d02d0291bcb62f019d5eec11c57c8ed differ diff --git a/fuzz/corpus/alloc_ops/e6e84ccbf905be7ddaff846bd609ede15f3ccdfc b/fuzz/corpus/alloc_ops/e6e84ccbf905be7ddaff846bd609ede15f3ccdfc new file mode 100644 index 0000000..c908063 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e6e84ccbf905be7ddaff846bd609ede15f3ccdfc differ diff --git a/fuzz/corpus/alloc_ops/e6f7e663a2b5eeef8f64492ef3f57fdf6dc26e97 b/fuzz/corpus/alloc_ops/e6f7e663a2b5eeef8f64492ef3f57fdf6dc26e97 new file mode 100644 index 0000000..37d3261 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e6f7e663a2b5eeef8f64492ef3f57fdf6dc26e97 differ diff --git a/fuzz/corpus/alloc_ops/e721e357c92720941b9dcf6add7bb302e434b291 b/fuzz/corpus/alloc_ops/e721e357c92720941b9dcf6add7bb302e434b291 new file mode 100644 index 0000000..fad5dbc Binary files /dev/null and b/fuzz/corpus/alloc_ops/e721e357c92720941b9dcf6add7bb302e434b291 differ diff --git a/fuzz/corpus/alloc_ops/e73c3a37400506188b658a8d6f1ad8353bb78e7f b/fuzz/corpus/alloc_ops/e73c3a37400506188b658a8d6f1ad8353bb78e7f new file mode 100644 index 0000000..a6551ee Binary files /dev/null and b/fuzz/corpus/alloc_ops/e73c3a37400506188b658a8d6f1ad8353bb78e7f differ diff --git a/fuzz/corpus/alloc_ops/e7546d59f004fe8f703b19e7be13edda5e78d640 b/fuzz/corpus/alloc_ops/e7546d59f004fe8f703b19e7be13edda5e78d640 new file mode 100644 index 0000000..acc4a51 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e7546d59f004fe8f703b19e7be13edda5e78d640 differ diff --git a/fuzz/corpus/alloc_ops/e75e6675f0bf81c23ad01c8a298799992d4b15e8 b/fuzz/corpus/alloc_ops/e75e6675f0bf81c23ad01c8a298799992d4b15e8 new file mode 100644 index 0000000..34d326a Binary files /dev/null and b/fuzz/corpus/alloc_ops/e75e6675f0bf81c23ad01c8a298799992d4b15e8 differ diff --git a/fuzz/corpus/alloc_ops/e7722b50925a8c5635baf1174a732da152d44c46 b/fuzz/corpus/alloc_ops/e7722b50925a8c5635baf1174a732da152d44c46 new file mode 100644 index 0000000..882f2da Binary files /dev/null and b/fuzz/corpus/alloc_ops/e7722b50925a8c5635baf1174a732da152d44c46 differ diff --git a/fuzz/corpus/alloc_ops/e78c50d28ad9d85c0ece228319cd23987d1e0574 b/fuzz/corpus/alloc_ops/e78c50d28ad9d85c0ece228319cd23987d1e0574 new file mode 100644 index 0000000..c8468a5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e78c50d28ad9d85c0ece228319cd23987d1e0574 differ diff --git a/fuzz/corpus/alloc_ops/e7abf38dc837cfd84150a75b8709d8142c5a6ab2 b/fuzz/corpus/alloc_ops/e7abf38dc837cfd84150a75b8709d8142c5a6ab2 new file mode 100644 index 0000000..ac32bb2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e7abf38dc837cfd84150a75b8709d8142c5a6ab2 differ diff --git a/fuzz/corpus/alloc_ops/e7cac786f9585cf82030c405109897765ddae168 b/fuzz/corpus/alloc_ops/e7cac786f9585cf82030c405109897765ddae168 new file mode 100644 index 0000000..685ea3c Binary files /dev/null and b/fuzz/corpus/alloc_ops/e7cac786f9585cf82030c405109897765ddae168 differ diff --git a/fuzz/corpus/alloc_ops/e83d2a8412b62278135e7c00a1d4f7e383873459 b/fuzz/corpus/alloc_ops/e83d2a8412b62278135e7c00a1d4f7e383873459 new file mode 100644 index 0000000..9d1ef59 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e83d2a8412b62278135e7c00a1d4f7e383873459 differ diff --git a/fuzz/corpus/alloc_ops/e8587d9b390730326276bf9244c714c299ffb40e b/fuzz/corpus/alloc_ops/e8587d9b390730326276bf9244c714c299ffb40e new file mode 100644 index 0000000..053158e Binary files /dev/null and b/fuzz/corpus/alloc_ops/e8587d9b390730326276bf9244c714c299ffb40e differ diff --git a/fuzz/corpus/alloc_ops/e862068695de1022d905e0a9307e5871b3bd9740 b/fuzz/corpus/alloc_ops/e862068695de1022d905e0a9307e5871b3bd9740 new file mode 100644 index 0000000..26a4948 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e862068695de1022d905e0a9307e5871b3bd9740 differ diff --git a/fuzz/corpus/alloc_ops/e88869c008d6d3e1607acef7941624016a44fce8 b/fuzz/corpus/alloc_ops/e88869c008d6d3e1607acef7941624016a44fce8 new file mode 100644 index 0000000..5b58a47 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e88869c008d6d3e1607acef7941624016a44fce8 differ diff --git a/fuzz/corpus/alloc_ops/e8908c97892e064ebb3a6f81b97df8e61cf10141 b/fuzz/corpus/alloc_ops/e8908c97892e064ebb3a6f81b97df8e61cf10141 new file mode 100644 index 0000000..1a66ba5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e8908c97892e064ebb3a6f81b97df8e61cf10141 differ diff --git a/fuzz/corpus/alloc_ops/e8e939fcdbc3411a52150a98989c511097d65d93 b/fuzz/corpus/alloc_ops/e8e939fcdbc3411a52150a98989c511097d65d93 new file mode 100644 index 0000000..9d024c9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e8e939fcdbc3411a52150a98989c511097d65d93 differ diff --git a/fuzz/corpus/alloc_ops/e90ad1accf10c974bac2c14f7a2160bbfda58c2f b/fuzz/corpus/alloc_ops/e90ad1accf10c974bac2c14f7a2160bbfda58c2f new file mode 100644 index 0000000..58aaed9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e90ad1accf10c974bac2c14f7a2160bbfda58c2f differ diff --git a/fuzz/corpus/alloc_ops/e9af23ae45dfb3f59ed8445cf4ac2428159dca7b b/fuzz/corpus/alloc_ops/e9af23ae45dfb3f59ed8445cf4ac2428159dca7b new file mode 100644 index 0000000..39f6db1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e9af23ae45dfb3f59ed8445cf4ac2428159dca7b differ diff --git a/fuzz/corpus/alloc_ops/e9f2d1d82704d1660520ada7378dd7cbd52e58e4 b/fuzz/corpus/alloc_ops/e9f2d1d82704d1660520ada7378dd7cbd52e58e4 new file mode 100644 index 0000000..e9af4a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/e9f2d1d82704d1660520ada7378dd7cbd52e58e4 differ diff --git a/fuzz/corpus/alloc_ops/ea07dd3f59fad308e23a7c0a5ebadbbca881b201 b/fuzz/corpus/alloc_ops/ea07dd3f59fad308e23a7c0a5ebadbbca881b201 new file mode 100644 index 0000000..9bd9668 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ea07dd3f59fad308e23a7c0a5ebadbbca881b201 differ diff --git a/fuzz/corpus/alloc_ops/ea37b8759523aa3c14843b27e53e6d56dfe1d555 b/fuzz/corpus/alloc_ops/ea37b8759523aa3c14843b27e53e6d56dfe1d555 new file mode 100644 index 0000000..9c2317e Binary files /dev/null and b/fuzz/corpus/alloc_ops/ea37b8759523aa3c14843b27e53e6d56dfe1d555 differ diff --git a/fuzz/corpus/alloc_ops/ea8eecb6973e809e6e6f71a0dfb5c387bbc5e8e2 b/fuzz/corpus/alloc_ops/ea8eecb6973e809e6e6f71a0dfb5c387bbc5e8e2 new file mode 100644 index 0000000..e9d2416 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ea8eecb6973e809e6e6f71a0dfb5c387bbc5e8e2 differ diff --git a/fuzz/corpus/alloc_ops/eabaed77f4d02e7010fdca58dbda08cccf736089 b/fuzz/corpus/alloc_ops/eabaed77f4d02e7010fdca58dbda08cccf736089 new file mode 100644 index 0000000..6b9bb18 Binary files /dev/null and b/fuzz/corpus/alloc_ops/eabaed77f4d02e7010fdca58dbda08cccf736089 differ diff --git a/fuzz/corpus/alloc_ops/eacd83d07139697094e61c85b8d894c08d6af418 b/fuzz/corpus/alloc_ops/eacd83d07139697094e61c85b8d894c08d6af418 new file mode 100644 index 0000000..818167f Binary files /dev/null and b/fuzz/corpus/alloc_ops/eacd83d07139697094e61c85b8d894c08d6af418 differ diff --git a/fuzz/corpus/alloc_ops/eb0e3554b3e3a7fb92f7b41320a9acee2a845a55 b/fuzz/corpus/alloc_ops/eb0e3554b3e3a7fb92f7b41320a9acee2a845a55 new file mode 100644 index 0000000..fcda47b Binary files /dev/null and b/fuzz/corpus/alloc_ops/eb0e3554b3e3a7fb92f7b41320a9acee2a845a55 differ diff --git a/fuzz/corpus/alloc_ops/eb1b18fcd4eebe3ffc2472d3277eaa302849c5d7 b/fuzz/corpus/alloc_ops/eb1b18fcd4eebe3ffc2472d3277eaa302849c5d7 new file mode 100644 index 0000000..038b22f Binary files /dev/null and b/fuzz/corpus/alloc_ops/eb1b18fcd4eebe3ffc2472d3277eaa302849c5d7 differ diff --git a/fuzz/corpus/alloc_ops/eb71dfeb78367d340df07fdf4d06eb179edb8a80 b/fuzz/corpus/alloc_ops/eb71dfeb78367d340df07fdf4d06eb179edb8a80 new file mode 100644 index 0000000..9a1968b Binary files /dev/null and b/fuzz/corpus/alloc_ops/eb71dfeb78367d340df07fdf4d06eb179edb8a80 differ diff --git a/fuzz/corpus/alloc_ops/ebcdaed6b22c92c1559caf66edcb4f134b3e9428 b/fuzz/corpus/alloc_ops/ebcdaed6b22c92c1559caf66edcb4f134b3e9428 new file mode 100644 index 0000000..51d6383 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ebcdaed6b22c92c1559caf66edcb4f134b3e9428 differ diff --git a/fuzz/corpus/alloc_ops/ebd812c873e792ba207d3e08cef76e2d38621176 b/fuzz/corpus/alloc_ops/ebd812c873e792ba207d3e08cef76e2d38621176 new file mode 100644 index 0000000..b2cbc62 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ebd812c873e792ba207d3e08cef76e2d38621176 differ diff --git a/fuzz/corpus/alloc_ops/ebf7e0acce255195ce4779e0cfa8f9138a73f8c7 b/fuzz/corpus/alloc_ops/ebf7e0acce255195ce4779e0cfa8f9138a73f8c7 new file mode 100644 index 0000000..c10675b Binary files /dev/null and b/fuzz/corpus/alloc_ops/ebf7e0acce255195ce4779e0cfa8f9138a73f8c7 differ diff --git a/fuzz/corpus/alloc_ops/ecce019472518ca1c037812f7bbb29dc56a49de5 b/fuzz/corpus/alloc_ops/ecce019472518ca1c037812f7bbb29dc56a49de5 new file mode 100644 index 0000000..8a95b75 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ecce019472518ca1c037812f7bbb29dc56a49de5 differ diff --git a/fuzz/corpus/alloc_ops/ed29662fc3d7f389526544e21d6ec275266511e7 b/fuzz/corpus/alloc_ops/ed29662fc3d7f389526544e21d6ec275266511e7 new file mode 100644 index 0000000..ac680f5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ed29662fc3d7f389526544e21d6ec275266511e7 differ diff --git a/fuzz/corpus/alloc_ops/ed57a92df637c5558aff1bcef85554de4921cdf2 b/fuzz/corpus/alloc_ops/ed57a92df637c5558aff1bcef85554de4921cdf2 new file mode 100644 index 0000000..50d2c7a Binary files /dev/null and b/fuzz/corpus/alloc_ops/ed57a92df637c5558aff1bcef85554de4921cdf2 differ diff --git a/fuzz/corpus/alloc_ops/ed631b65231dcc604635056bc245a8f057769ba7 b/fuzz/corpus/alloc_ops/ed631b65231dcc604635056bc245a8f057769ba7 new file mode 100644 index 0000000..e1ad9d5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ed631b65231dcc604635056bc245a8f057769ba7 differ diff --git a/fuzz/corpus/alloc_ops/ed9dc7405316ea9ce711ca421b720709ff0e6aa1 b/fuzz/corpus/alloc_ops/ed9dc7405316ea9ce711ca421b720709ff0e6aa1 new file mode 100644 index 0000000..faf69b4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ed9dc7405316ea9ce711ca421b720709ff0e6aa1 differ diff --git a/fuzz/corpus/alloc_ops/edc2c5bea7d2f9905ff597d033be7d0a0dd3b471 b/fuzz/corpus/alloc_ops/edc2c5bea7d2f9905ff597d033be7d0a0dd3b471 new file mode 100644 index 0000000..7db43be Binary files /dev/null and b/fuzz/corpus/alloc_ops/edc2c5bea7d2f9905ff597d033be7d0a0dd3b471 differ diff --git a/fuzz/corpus/alloc_ops/edcf47d0bb0eb6a5904a0a3da6e1c28825fdfaf1 b/fuzz/corpus/alloc_ops/edcf47d0bb0eb6a5904a0a3da6e1c28825fdfaf1 new file mode 100644 index 0000000..42040e2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/edcf47d0bb0eb6a5904a0a3da6e1c28825fdfaf1 differ diff --git a/fuzz/corpus/alloc_ops/ede72dcd3a50bef9ad9a0c5df990291f8093a257 b/fuzz/corpus/alloc_ops/ede72dcd3a50bef9ad9a0c5df990291f8093a257 new file mode 100644 index 0000000..ff25674 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ede72dcd3a50bef9ad9a0c5df990291f8093a257 differ diff --git a/fuzz/corpus/alloc_ops/edff77ef0b34b024088e5b5ac392d09992d09157 b/fuzz/corpus/alloc_ops/edff77ef0b34b024088e5b5ac392d09992d09157 new file mode 100644 index 0000000..ccf1045 Binary files /dev/null and b/fuzz/corpus/alloc_ops/edff77ef0b34b024088e5b5ac392d09992d09157 differ diff --git a/fuzz/corpus/alloc_ops/ee1b9db7627c1b30caa5b95b03ce5f80de17cb2a b/fuzz/corpus/alloc_ops/ee1b9db7627c1b30caa5b95b03ce5f80de17cb2a new file mode 100644 index 0000000..321cd05 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ee1b9db7627c1b30caa5b95b03ce5f80de17cb2a differ diff --git a/fuzz/corpus/alloc_ops/ee6efe81dcd06e374421c4a82f21596ad18914bc b/fuzz/corpus/alloc_ops/ee6efe81dcd06e374421c4a82f21596ad18914bc new file mode 100644 index 0000000..f6ec316 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ee6efe81dcd06e374421c4a82f21596ad18914bc differ diff --git a/fuzz/corpus/alloc_ops/ef4181a2f457b70ecc6528735a1cbab2ad003eb2 b/fuzz/corpus/alloc_ops/ef4181a2f457b70ecc6528735a1cbab2ad003eb2 new file mode 100644 index 0000000..c9c8bf2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ef4181a2f457b70ecc6528735a1cbab2ad003eb2 differ diff --git a/fuzz/corpus/alloc_ops/ef65c0e39879e23390c45defcd7b104c246eedde b/fuzz/corpus/alloc_ops/ef65c0e39879e23390c45defcd7b104c246eedde new file mode 100644 index 0000000..a3d3d44 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ef65c0e39879e23390c45defcd7b104c246eedde differ diff --git a/fuzz/corpus/alloc_ops/ef9aaf007f6ac3b9f2b2fa66ddda1b09d5f87e59 b/fuzz/corpus/alloc_ops/ef9aaf007f6ac3b9f2b2fa66ddda1b09d5f87e59 new file mode 100644 index 0000000..416361e Binary files /dev/null and b/fuzz/corpus/alloc_ops/ef9aaf007f6ac3b9f2b2fa66ddda1b09d5f87e59 differ diff --git a/fuzz/corpus/alloc_ops/efd16a4389bf323fce8af82cb30c37fd7d92adc6 b/fuzz/corpus/alloc_ops/efd16a4389bf323fce8af82cb30c37fd7d92adc6 new file mode 100644 index 0000000..4429c9e Binary files /dev/null and b/fuzz/corpus/alloc_ops/efd16a4389bf323fce8af82cb30c37fd7d92adc6 differ diff --git a/fuzz/corpus/alloc_ops/f019713b772cf9cf743e6b00072ef552b51ed0dc b/fuzz/corpus/alloc_ops/f019713b772cf9cf743e6b00072ef552b51ed0dc new file mode 100644 index 0000000..a9afca8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f019713b772cf9cf743e6b00072ef552b51ed0dc differ diff --git a/fuzz/corpus/alloc_ops/f02b5853ef5a68ddc00e96c14e1f21edbf3af171 b/fuzz/corpus/alloc_ops/f02b5853ef5a68ddc00e96c14e1f21edbf3af171 new file mode 100644 index 0000000..dc26ce5 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f02b5853ef5a68ddc00e96c14e1f21edbf3af171 differ diff --git a/fuzz/corpus/alloc_ops/f03160e60d54075ec5c44477f0b00cf22a06179f b/fuzz/corpus/alloc_ops/f03160e60d54075ec5c44477f0b00cf22a06179f new file mode 100644 index 0000000..e0e611c Binary files /dev/null and b/fuzz/corpus/alloc_ops/f03160e60d54075ec5c44477f0b00cf22a06179f differ diff --git a/fuzz/corpus/alloc_ops/f03558915c8434b80d6c8b3f8dddd831376eef9b b/fuzz/corpus/alloc_ops/f03558915c8434b80d6c8b3f8dddd831376eef9b new file mode 100644 index 0000000..6c2ec85 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f03558915c8434b80d6c8b3f8dddd831376eef9b differ diff --git a/fuzz/corpus/alloc_ops/f0ad2f2abde2f49becc735310336c8fb1ad1e894 b/fuzz/corpus/alloc_ops/f0ad2f2abde2f49becc735310336c8fb1ad1e894 new file mode 100644 index 0000000..bb1113d Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0ad2f2abde2f49becc735310336c8fb1ad1e894 differ diff --git a/fuzz/corpus/alloc_ops/f0c8f5bae0b85b3de08a1b68c294b853891ef9fe b/fuzz/corpus/alloc_ops/f0c8f5bae0b85b3de08a1b68c294b853891ef9fe new file mode 100644 index 0000000..dbf815a Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0c8f5bae0b85b3de08a1b68c294b853891ef9fe differ diff --git a/fuzz/corpus/alloc_ops/f0c9f346b1ee34065c8bccd69fc7edd36f5e9677 b/fuzz/corpus/alloc_ops/f0c9f346b1ee34065c8bccd69fc7edd36f5e9677 new file mode 100644 index 0000000..c8d3121 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0c9f346b1ee34065c8bccd69fc7edd36f5e9677 differ diff --git a/fuzz/corpus/alloc_ops/f0d5c0ed1ffebb55cef9cffae81721738e1d3cd1 b/fuzz/corpus/alloc_ops/f0d5c0ed1ffebb55cef9cffae81721738e1d3cd1 new file mode 100644 index 0000000..e3caabb Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0d5c0ed1ffebb55cef9cffae81721738e1d3cd1 differ diff --git a/fuzz/corpus/alloc_ops/f0d6097e1287836496ce27255a62778069902aee b/fuzz/corpus/alloc_ops/f0d6097e1287836496ce27255a62778069902aee new file mode 100644 index 0000000..55ab0e7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0d6097e1287836496ce27255a62778069902aee differ diff --git a/fuzz/corpus/alloc_ops/f0d9b329bd4a498027c2a827fa30ce20f19f0ae6 b/fuzz/corpus/alloc_ops/f0d9b329bd4a498027c2a827fa30ce20f19f0ae6 new file mode 100644 index 0000000..d3731fa Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0d9b329bd4a498027c2a827fa30ce20f19f0ae6 differ diff --git a/fuzz/corpus/alloc_ops/f0f3165d8b74c4ea2a5597c8d62760cdfa79a0c3 b/fuzz/corpus/alloc_ops/f0f3165d8b74c4ea2a5597c8d62760cdfa79a0c3 new file mode 100644 index 0000000..e53fc09 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f0f3165d8b74c4ea2a5597c8d62760cdfa79a0c3 differ diff --git a/fuzz/corpus/alloc_ops/f15c9060c1513cee24ff2adae78322901cf735b3 b/fuzz/corpus/alloc_ops/f15c9060c1513cee24ff2adae78322901cf735b3 new file mode 100644 index 0000000..6ee9605 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f15c9060c1513cee24ff2adae78322901cf735b3 differ diff --git a/fuzz/corpus/alloc_ops/f163c651aeab28db887bf4f35fda0306c5c7caf8 b/fuzz/corpus/alloc_ops/f163c651aeab28db887bf4f35fda0306c5c7caf8 new file mode 100644 index 0000000..27e2dd4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f163c651aeab28db887bf4f35fda0306c5c7caf8 differ diff --git a/fuzz/corpus/alloc_ops/f1a8540ed23a055f4a1037be5bf4036a75bc1286 b/fuzz/corpus/alloc_ops/f1a8540ed23a055f4a1037be5bf4036a75bc1286 new file mode 100644 index 0000000..f62337e Binary files /dev/null and b/fuzz/corpus/alloc_ops/f1a8540ed23a055f4a1037be5bf4036a75bc1286 differ diff --git a/fuzz/corpus/alloc_ops/f24f8e393027ed6ad713c0db23e96be58066535d b/fuzz/corpus/alloc_ops/f24f8e393027ed6ad713c0db23e96be58066535d new file mode 100644 index 0000000..bd44d13 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f24f8e393027ed6ad713c0db23e96be58066535d differ diff --git a/fuzz/corpus/alloc_ops/f255c1f410883053baf1865b8704ec0836fc46c2 b/fuzz/corpus/alloc_ops/f255c1f410883053baf1865b8704ec0836fc46c2 new file mode 100644 index 0000000..ce62a48 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f255c1f410883053baf1865b8704ec0836fc46c2 differ diff --git a/fuzz/corpus/alloc_ops/f26a6e8f337b2345a3e54b00f312338e775c48ab b/fuzz/corpus/alloc_ops/f26a6e8f337b2345a3e54b00f312338e775c48ab new file mode 100644 index 0000000..8e00820 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f26a6e8f337b2345a3e54b00f312338e775c48ab differ diff --git a/fuzz/corpus/alloc_ops/f29388c09cc13581ea5d8e6230a6868935c8d4bd b/fuzz/corpus/alloc_ops/f29388c09cc13581ea5d8e6230a6868935c8d4bd new file mode 100644 index 0000000..e0e419a Binary files /dev/null and b/fuzz/corpus/alloc_ops/f29388c09cc13581ea5d8e6230a6868935c8d4bd differ diff --git a/fuzz/corpus/alloc_ops/f2bcda850562ba5b6e4b28fcb6d9f71232398dc1 b/fuzz/corpus/alloc_ops/f2bcda850562ba5b6e4b28fcb6d9f71232398dc1 new file mode 100644 index 0000000..cb3d8ab Binary files /dev/null and b/fuzz/corpus/alloc_ops/f2bcda850562ba5b6e4b28fcb6d9f71232398dc1 differ diff --git a/fuzz/corpus/alloc_ops/f2c7b6c7b97f52b64f39064c438fbac8c62642d9 b/fuzz/corpus/alloc_ops/f2c7b6c7b97f52b64f39064c438fbac8c62642d9 new file mode 100644 index 0000000..3a3aa58 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f2c7b6c7b97f52b64f39064c438fbac8c62642d9 differ diff --git a/fuzz/corpus/alloc_ops/f32d9a7643a4d3967c6d8ef57f5b6233ed5cc7e3 b/fuzz/corpus/alloc_ops/f32d9a7643a4d3967c6d8ef57f5b6233ed5cc7e3 new file mode 100644 index 0000000..25eed94 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f32d9a7643a4d3967c6d8ef57f5b6233ed5cc7e3 differ diff --git a/fuzz/corpus/alloc_ops/f3b0517f6dd3e24c4cbd14919cc3e74ae1b5350c b/fuzz/corpus/alloc_ops/f3b0517f6dd3e24c4cbd14919cc3e74ae1b5350c new file mode 100644 index 0000000..c79c8c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f3b0517f6dd3e24c4cbd14919cc3e74ae1b5350c differ diff --git a/fuzz/corpus/alloc_ops/f3c013e4d6ad3c0b047d6838103c1abd9d0f30b3 b/fuzz/corpus/alloc_ops/f3c013e4d6ad3c0b047d6838103c1abd9d0f30b3 new file mode 100644 index 0000000..1e2f8e9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f3c013e4d6ad3c0b047d6838103c1abd9d0f30b3 differ diff --git a/fuzz/corpus/alloc_ops/f4089d32485da5dcc449a159d91f7fb738bb130d b/fuzz/corpus/alloc_ops/f4089d32485da5dcc449a159d91f7fb738bb130d new file mode 100644 index 0000000..b97858b Binary files /dev/null and b/fuzz/corpus/alloc_ops/f4089d32485da5dcc449a159d91f7fb738bb130d differ diff --git a/fuzz/corpus/alloc_ops/f425914e69bd4a486cc19478fd708476ea8a12bd b/fuzz/corpus/alloc_ops/f425914e69bd4a486cc19478fd708476ea8a12bd new file mode 100644 index 0000000..ef0db95 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f425914e69bd4a486cc19478fd708476ea8a12bd differ diff --git a/fuzz/corpus/alloc_ops/f4577d0e194f2957670869f35fbdc93abe896d3e b/fuzz/corpus/alloc_ops/f4577d0e194f2957670869f35fbdc93abe896d3e new file mode 100644 index 0000000..2378c80 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f4577d0e194f2957670869f35fbdc93abe896d3e differ diff --git a/fuzz/corpus/alloc_ops/f48e0a6bcd874878c7ecec1d8e514f7885d16128 b/fuzz/corpus/alloc_ops/f48e0a6bcd874878c7ecec1d8e514f7885d16128 new file mode 100644 index 0000000..ded7d61 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f48e0a6bcd874878c7ecec1d8e514f7885d16128 differ diff --git a/fuzz/corpus/alloc_ops/f499f998499ec1f1188b425083c042330ac57eac b/fuzz/corpus/alloc_ops/f499f998499ec1f1188b425083c042330ac57eac new file mode 100644 index 0000000..fd5eeb2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f499f998499ec1f1188b425083c042330ac57eac differ diff --git a/fuzz/corpus/alloc_ops/f4b53a17adc5b4716bb8f4d49533fd874604aedd b/fuzz/corpus/alloc_ops/f4b53a17adc5b4716bb8f4d49533fd874604aedd new file mode 100644 index 0000000..8ccc4c1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f4b53a17adc5b4716bb8f4d49533fd874604aedd differ diff --git a/fuzz/corpus/alloc_ops/f53037d7d74e20ad36c5483656fdac724b533d42 b/fuzz/corpus/alloc_ops/f53037d7d74e20ad36c5483656fdac724b533d42 new file mode 100644 index 0000000..6dace23 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f53037d7d74e20ad36c5483656fdac724b533d42 differ diff --git a/fuzz/corpus/alloc_ops/f5387d4f57a36c7028cedd23d7d8ca9338a046c6 b/fuzz/corpus/alloc_ops/f5387d4f57a36c7028cedd23d7d8ca9338a046c6 new file mode 100644 index 0000000..8373e83 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f5387d4f57a36c7028cedd23d7d8ca9338a046c6 differ diff --git a/fuzz/corpus/alloc_ops/f53bab1c64118a637f7333f22fa910288a144b14 b/fuzz/corpus/alloc_ops/f53bab1c64118a637f7333f22fa910288a144b14 new file mode 100644 index 0000000..6e987d6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f53bab1c64118a637f7333f22fa910288a144b14 differ diff --git a/fuzz/corpus/alloc_ops/f53efa82a3fea24424d40df123a969de9868e80b b/fuzz/corpus/alloc_ops/f53efa82a3fea24424d40df123a969de9868e80b new file mode 100644 index 0000000..f10cc28 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f53efa82a3fea24424d40df123a969de9868e80b differ diff --git a/fuzz/corpus/alloc_ops/f56b4113b553cf56a5e632ff49867075d33ffd36 b/fuzz/corpus/alloc_ops/f56b4113b553cf56a5e632ff49867075d33ffd36 new file mode 100644 index 0000000..87e3fd7 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f56b4113b553cf56a5e632ff49867075d33ffd36 differ diff --git a/fuzz/corpus/alloc_ops/f581711023d656d04b92962f673fb89375ec5156 b/fuzz/corpus/alloc_ops/f581711023d656d04b92962f673fb89375ec5156 new file mode 100644 index 0000000..41d71f8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f581711023d656d04b92962f673fb89375ec5156 differ diff --git a/fuzz/corpus/alloc_ops/f5e4cbb6470c0c432be7c75551ee3833c5b32f1f b/fuzz/corpus/alloc_ops/f5e4cbb6470c0c432be7c75551ee3833c5b32f1f new file mode 100644 index 0000000..0a289ca Binary files /dev/null and b/fuzz/corpus/alloc_ops/f5e4cbb6470c0c432be7c75551ee3833c5b32f1f differ diff --git a/fuzz/corpus/alloc_ops/f616274aede23221dc8e95a771b0cef3cca6c3d8 b/fuzz/corpus/alloc_ops/f616274aede23221dc8e95a771b0cef3cca6c3d8 new file mode 100644 index 0000000..0c39725 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f616274aede23221dc8e95a771b0cef3cca6c3d8 differ diff --git a/fuzz/corpus/alloc_ops/f633a003335cd36971783944fcd59f8fbe408400 b/fuzz/corpus/alloc_ops/f633a003335cd36971783944fcd59f8fbe408400 new file mode 100644 index 0000000..ccf4e85 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f633a003335cd36971783944fcd59f8fbe408400 differ diff --git a/fuzz/corpus/alloc_ops/f6355d3ecd7b6dd00524c2defc3f30f0f9dea4f5 b/fuzz/corpus/alloc_ops/f6355d3ecd7b6dd00524c2defc3f30f0f9dea4f5 new file mode 100644 index 0000000..4c9f82c Binary files /dev/null and b/fuzz/corpus/alloc_ops/f6355d3ecd7b6dd00524c2defc3f30f0f9dea4f5 differ diff --git a/fuzz/corpus/alloc_ops/f65a9c99e6cf97a4356ffa691b9d19c26e397acd b/fuzz/corpus/alloc_ops/f65a9c99e6cf97a4356ffa691b9d19c26e397acd new file mode 100644 index 0000000..c5b3949 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f65a9c99e6cf97a4356ffa691b9d19c26e397acd differ diff --git a/fuzz/corpus/alloc_ops/f66866e2efe96af2aeaaa840bfa4f24bdd18a9a7 b/fuzz/corpus/alloc_ops/f66866e2efe96af2aeaaa840bfa4f24bdd18a9a7 new file mode 100644 index 0000000..a2449f4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f66866e2efe96af2aeaaa840bfa4f24bdd18a9a7 differ diff --git a/fuzz/corpus/alloc_ops/f6ab13dd43bd65b8bab37126ee495545045e710a b/fuzz/corpus/alloc_ops/f6ab13dd43bd65b8bab37126ee495545045e710a new file mode 100644 index 0000000..513c380 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f6ab13dd43bd65b8bab37126ee495545045e710a differ diff --git a/fuzz/corpus/alloc_ops/f6b33c94f51609c27402b1d04bb6a6b951e39a45 b/fuzz/corpus/alloc_ops/f6b33c94f51609c27402b1d04bb6a6b951e39a45 new file mode 100644 index 0000000..f8ca5b0 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f6b33c94f51609c27402b1d04bb6a6b951e39a45 differ diff --git a/fuzz/corpus/alloc_ops/f6c1d759699c1634cac09753f843fa9171e62ca0 b/fuzz/corpus/alloc_ops/f6c1d759699c1634cac09753f843fa9171e62ca0 new file mode 100644 index 0000000..6b435a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f6c1d759699c1634cac09753f843fa9171e62ca0 differ diff --git a/fuzz/corpus/alloc_ops/f766460bda6847a31b831f9613cbdbdf5e2c8d19 b/fuzz/corpus/alloc_ops/f766460bda6847a31b831f9613cbdbdf5e2c8d19 new file mode 100644 index 0000000..f854026 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f766460bda6847a31b831f9613cbdbdf5e2c8d19 differ diff --git a/fuzz/corpus/alloc_ops/f7853464fee9a01a69acd85402da08dc45c43075 b/fuzz/corpus/alloc_ops/f7853464fee9a01a69acd85402da08dc45c43075 new file mode 100644 index 0000000..6be108a Binary files /dev/null and b/fuzz/corpus/alloc_ops/f7853464fee9a01a69acd85402da08dc45c43075 differ diff --git a/fuzz/corpus/alloc_ops/f786695392bdaf434c81dc0f1b6c115709e6748e b/fuzz/corpus/alloc_ops/f786695392bdaf434c81dc0f1b6c115709e6748e new file mode 100644 index 0000000..868eb85 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f786695392bdaf434c81dc0f1b6c115709e6748e differ diff --git a/fuzz/corpus/alloc_ops/f7b3448acb9c126c6dc6978a4e6ff71c21e9f02f b/fuzz/corpus/alloc_ops/f7b3448acb9c126c6dc6978a4e6ff71c21e9f02f new file mode 100644 index 0000000..eeb9f80 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f7b3448acb9c126c6dc6978a4e6ff71c21e9f02f differ diff --git a/fuzz/corpus/alloc_ops/f7eff7392dc8ada0fe9249353b9ecadadfb1739c b/fuzz/corpus/alloc_ops/f7eff7392dc8ada0fe9249353b9ecadadfb1739c new file mode 100644 index 0000000..d57ecf3 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f7eff7392dc8ada0fe9249353b9ecadadfb1739c differ diff --git a/fuzz/corpus/alloc_ops/f7fd51f9052a7b079cb463bc85eb68efa52ef144 b/fuzz/corpus/alloc_ops/f7fd51f9052a7b079cb463bc85eb68efa52ef144 new file mode 100644 index 0000000..7307901 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f7fd51f9052a7b079cb463bc85eb68efa52ef144 differ diff --git a/fuzz/corpus/alloc_ops/f8031b3cae7d23f6c57b9fb4d6f08a93ea72fc8a b/fuzz/corpus/alloc_ops/f8031b3cae7d23f6c57b9fb4d6f08a93ea72fc8a new file mode 100644 index 0000000..8a94125 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f8031b3cae7d23f6c57b9fb4d6f08a93ea72fc8a differ diff --git a/fuzz/corpus/alloc_ops/f87a37ef6d9efddc7a40cf576a809073e51531d7 b/fuzz/corpus/alloc_ops/f87a37ef6d9efddc7a40cf576a809073e51531d7 new file mode 100644 index 0000000..a9b6d59 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f87a37ef6d9efddc7a40cf576a809073e51531d7 differ diff --git a/fuzz/corpus/alloc_ops/f88666dd2e8af025245d63219742933e30868ef9 b/fuzz/corpus/alloc_ops/f88666dd2e8af025245d63219742933e30868ef9 new file mode 100644 index 0000000..1b661eb Binary files /dev/null and b/fuzz/corpus/alloc_ops/f88666dd2e8af025245d63219742933e30868ef9 differ diff --git a/fuzz/corpus/alloc_ops/f8b35c3c97b11ef0035601400e53cbee0d04a176 b/fuzz/corpus/alloc_ops/f8b35c3c97b11ef0035601400e53cbee0d04a176 new file mode 100644 index 0000000..e4b91b1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f8b35c3c97b11ef0035601400e53cbee0d04a176 differ diff --git a/fuzz/corpus/alloc_ops/f8ce1112a120d21c39b460f2f9d3172839ab7d68 b/fuzz/corpus/alloc_ops/f8ce1112a120d21c39b460f2f9d3172839ab7d68 new file mode 100644 index 0000000..0214a3a Binary files /dev/null and b/fuzz/corpus/alloc_ops/f8ce1112a120d21c39b460f2f9d3172839ab7d68 differ diff --git a/fuzz/corpus/alloc_ops/f97c52752afc82b235bcb63a8957ac37290cdd5f b/fuzz/corpus/alloc_ops/f97c52752afc82b235bcb63a8957ac37290cdd5f new file mode 100644 index 0000000..3805711 Binary files /dev/null and b/fuzz/corpus/alloc_ops/f97c52752afc82b235bcb63a8957ac37290cdd5f differ diff --git a/fuzz/corpus/alloc_ops/f9eed0dc3f9f78ce4addad453113755d91456e86 b/fuzz/corpus/alloc_ops/f9eed0dc3f9f78ce4addad453113755d91456e86 new file mode 100644 index 0000000..d9a084c Binary files /dev/null and b/fuzz/corpus/alloc_ops/f9eed0dc3f9f78ce4addad453113755d91456e86 differ diff --git a/fuzz/corpus/alloc_ops/fa21d29f94848ec06349c36e7aba1c5a4f61631f b/fuzz/corpus/alloc_ops/fa21d29f94848ec06349c36e7aba1c5a4f61631f new file mode 100644 index 0000000..34300c4 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fa21d29f94848ec06349c36e7aba1c5a4f61631f differ diff --git a/fuzz/corpus/alloc_ops/faacd6e7d56770f849913cc51c39a611e490c9a7 b/fuzz/corpus/alloc_ops/faacd6e7d56770f849913cc51c39a611e490c9a7 new file mode 100644 index 0000000..447ce06 Binary files /dev/null and b/fuzz/corpus/alloc_ops/faacd6e7d56770f849913cc51c39a611e490c9a7 differ diff --git a/fuzz/corpus/alloc_ops/fab7334a446744fc5494bdf3c3977a5bbe27034b b/fuzz/corpus/alloc_ops/fab7334a446744fc5494bdf3c3977a5bbe27034b new file mode 100644 index 0000000..745ab19 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fab7334a446744fc5494bdf3c3977a5bbe27034b differ diff --git a/fuzz/corpus/alloc_ops/fac337f5ebae432f5a75f4ee1c9be0c5266e5fee b/fuzz/corpus/alloc_ops/fac337f5ebae432f5a75f4ee1c9be0c5266e5fee new file mode 100644 index 0000000..2a59e6c Binary files /dev/null and b/fuzz/corpus/alloc_ops/fac337f5ebae432f5a75f4ee1c9be0c5266e5fee differ diff --git a/fuzz/corpus/alloc_ops/fb08bdf136dfed0dab9f600afcf6d77c12b418a2 b/fuzz/corpus/alloc_ops/fb08bdf136dfed0dab9f600afcf6d77c12b418a2 new file mode 100644 index 0000000..3c33a61 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fb08bdf136dfed0dab9f600afcf6d77c12b418a2 differ diff --git a/fuzz/corpus/alloc_ops/fb5df33503eba40578129f2424c92c8ff3b1d10e b/fuzz/corpus/alloc_ops/fb5df33503eba40578129f2424c92c8ff3b1d10e new file mode 100644 index 0000000..6216425 --- /dev/null +++ b/fuzz/corpus/alloc_ops/fb5df33503eba40578129f2424c92c8ff3b1d10e @@ -0,0 +1 @@ +æìö \ No newline at end of file diff --git a/fuzz/corpus/alloc_ops/fb60c467a91ed5350d98bd97c8a9b2e61dfbc43f b/fuzz/corpus/alloc_ops/fb60c467a91ed5350d98bd97c8a9b2e61dfbc43f new file mode 100644 index 0000000..ff7f2fb Binary files /dev/null and b/fuzz/corpus/alloc_ops/fb60c467a91ed5350d98bd97c8a9b2e61dfbc43f differ diff --git a/fuzz/corpus/alloc_ops/fb9a67b0278c9a2a5003c8943cec83f8f1512f38 b/fuzz/corpus/alloc_ops/fb9a67b0278c9a2a5003c8943cec83f8f1512f38 new file mode 100644 index 0000000..36e5a9e Binary files /dev/null and b/fuzz/corpus/alloc_ops/fb9a67b0278c9a2a5003c8943cec83f8f1512f38 differ diff --git a/fuzz/corpus/alloc_ops/fbba1a9859f16ffee68359520557a242c6b02efa b/fuzz/corpus/alloc_ops/fbba1a9859f16ffee68359520557a242c6b02efa new file mode 100644 index 0000000..791f2d8 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fbba1a9859f16ffee68359520557a242c6b02efa differ diff --git a/fuzz/corpus/alloc_ops/fc147881a26f2ea8a87d5d95ac5d63be1f903d1f b/fuzz/corpus/alloc_ops/fc147881a26f2ea8a87d5d95ac5d63be1f903d1f new file mode 100644 index 0000000..2ae396a Binary files /dev/null and b/fuzz/corpus/alloc_ops/fc147881a26f2ea8a87d5d95ac5d63be1f903d1f differ diff --git a/fuzz/corpus/alloc_ops/fd1c07dba33d71dbfd6b2310a4a4ae9f8f9737cf b/fuzz/corpus/alloc_ops/fd1c07dba33d71dbfd6b2310a4a4ae9f8f9737cf new file mode 100644 index 0000000..78e8b57 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fd1c07dba33d71dbfd6b2310a4a4ae9f8f9737cf differ diff --git a/fuzz/corpus/alloc_ops/fd2d4a0b448cc52b5c0fd902349ed109a8cd3553 b/fuzz/corpus/alloc_ops/fd2d4a0b448cc52b5c0fd902349ed109a8cd3553 new file mode 100644 index 0000000..510344c Binary files /dev/null and b/fuzz/corpus/alloc_ops/fd2d4a0b448cc52b5c0fd902349ed109a8cd3553 differ diff --git a/fuzz/corpus/alloc_ops/fd47c08029fe344ed13713eb518975dec27e9f65 b/fuzz/corpus/alloc_ops/fd47c08029fe344ed13713eb518975dec27e9f65 new file mode 100644 index 0000000..d424daf Binary files /dev/null and b/fuzz/corpus/alloc_ops/fd47c08029fe344ed13713eb518975dec27e9f65 differ diff --git a/fuzz/corpus/alloc_ops/fdb2da332de43e7c47bdd6818b658b575bfc7cc5 b/fuzz/corpus/alloc_ops/fdb2da332de43e7c47bdd6818b658b575bfc7cc5 new file mode 100644 index 0000000..115193d Binary files /dev/null and b/fuzz/corpus/alloc_ops/fdb2da332de43e7c47bdd6818b658b575bfc7cc5 differ diff --git a/fuzz/corpus/alloc_ops/fdda2ffb71e1dec59fdf988452d8414dd144ccaa b/fuzz/corpus/alloc_ops/fdda2ffb71e1dec59fdf988452d8414dd144ccaa new file mode 100644 index 0000000..ca669d2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fdda2ffb71e1dec59fdf988452d8414dd144ccaa differ diff --git a/fuzz/corpus/alloc_ops/fdfb1f9c30dac870e359c475666ee7d7333edc16 b/fuzz/corpus/alloc_ops/fdfb1f9c30dac870e359c475666ee7d7333edc16 new file mode 100644 index 0000000..1081f18 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fdfb1f9c30dac870e359c475666ee7d7333edc16 differ diff --git a/fuzz/corpus/alloc_ops/fdfd4cb58f2aa77c837e13afc25d5009b0e9deaa b/fuzz/corpus/alloc_ops/fdfd4cb58f2aa77c837e13afc25d5009b0e9deaa new file mode 100644 index 0000000..d40ffd1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fdfd4cb58f2aa77c837e13afc25d5009b0e9deaa differ diff --git a/fuzz/corpus/alloc_ops/fe02320436a4058dfce4c8c15d48c8db2cb14867 b/fuzz/corpus/alloc_ops/fe02320436a4058dfce4c8c15d48c8db2cb14867 new file mode 100644 index 0000000..8de043f Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe02320436a4058dfce4c8c15d48c8db2cb14867 differ diff --git a/fuzz/corpus/alloc_ops/fe1a6520251f791598ac4a5eaaa6b95a5072ea4c b/fuzz/corpus/alloc_ops/fe1a6520251f791598ac4a5eaaa6b95a5072ea4c new file mode 100644 index 0000000..3c15cbe Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe1a6520251f791598ac4a5eaaa6b95a5072ea4c differ diff --git a/fuzz/corpus/alloc_ops/fe1d4c15d21a552617332b562f0d7b3afeeb488c b/fuzz/corpus/alloc_ops/fe1d4c15d21a552617332b562f0d7b3afeeb488c new file mode 100644 index 0000000..a942620 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe1d4c15d21a552617332b562f0d7b3afeeb488c differ diff --git a/fuzz/corpus/alloc_ops/fe5d94cf0268b7beb979750cd9d9a83be719752f b/fuzz/corpus/alloc_ops/fe5d94cf0268b7beb979750cd9d9a83be719752f new file mode 100644 index 0000000..7e171b6 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe5d94cf0268b7beb979750cd9d9a83be719752f differ diff --git a/fuzz/corpus/alloc_ops/fe676a1d8eb0afc36530abe02774efa06bd2541f b/fuzz/corpus/alloc_ops/fe676a1d8eb0afc36530abe02774efa06bd2541f new file mode 100644 index 0000000..ea3006d Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe676a1d8eb0afc36530abe02774efa06bd2541f differ diff --git a/fuzz/corpus/alloc_ops/fe90b63fbb1cf0db8516df4ebaa823e71e46d347 b/fuzz/corpus/alloc_ops/fe90b63fbb1cf0db8516df4ebaa823e71e46d347 new file mode 100644 index 0000000..deb8cff Binary files /dev/null and b/fuzz/corpus/alloc_ops/fe90b63fbb1cf0db8516df4ebaa823e71e46d347 differ diff --git a/fuzz/corpus/alloc_ops/fee1351f814e8d1cb30b9511890d4b31a1c1e1a3 b/fuzz/corpus/alloc_ops/fee1351f814e8d1cb30b9511890d4b31a1c1e1a3 new file mode 100644 index 0000000..a3a80a9 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fee1351f814e8d1cb30b9511890d4b31a1c1e1a3 differ diff --git a/fuzz/corpus/alloc_ops/fee51145d3b8d257d5db4f0ae5bacb59d644a7a5 b/fuzz/corpus/alloc_ops/fee51145d3b8d257d5db4f0ae5bacb59d644a7a5 new file mode 100644 index 0000000..4428db1 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fee51145d3b8d257d5db4f0ae5bacb59d644a7a5 differ diff --git a/fuzz/corpus/alloc_ops/fef3fbb73d4bca9986a2bf920e495db5951e2acf b/fuzz/corpus/alloc_ops/fef3fbb73d4bca9986a2bf920e495db5951e2acf new file mode 100644 index 0000000..7c0ba63 Binary files /dev/null and b/fuzz/corpus/alloc_ops/fef3fbb73d4bca9986a2bf920e495db5951e2acf differ diff --git a/fuzz/corpus/alloc_ops/ff4e84919d4df350cc41dc8bffd9254672acdd83 b/fuzz/corpus/alloc_ops/ff4e84919d4df350cc41dc8bffd9254672acdd83 new file mode 100644 index 0000000..3028657 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ff4e84919d4df350cc41dc8bffd9254672acdd83 differ diff --git a/fuzz/corpus/alloc_ops/ff7ecd163c05214b786bb9ca32cec5836a87a416 b/fuzz/corpus/alloc_ops/ff7ecd163c05214b786bb9ca32cec5836a87a416 new file mode 100644 index 0000000..fdd44cd Binary files /dev/null and b/fuzz/corpus/alloc_ops/ff7ecd163c05214b786bb9ca32cec5836a87a416 differ diff --git a/fuzz/corpus/alloc_ops/ff7f744c1fc7536e094d2bd04be0f0a9695e7163 b/fuzz/corpus/alloc_ops/ff7f744c1fc7536e094d2bd04be0f0a9695e7163 new file mode 100644 index 0000000..ca030b2 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ff7f744c1fc7536e094d2bd04be0f0a9695e7163 differ diff --git a/fuzz/corpus/alloc_ops/ffc75037e28b305a61580ffcad00930f02115773 b/fuzz/corpus/alloc_ops/ffc75037e28b305a61580ffcad00930f02115773 new file mode 100644 index 0000000..b9a0d22 Binary files /dev/null and b/fuzz/corpus/alloc_ops/ffc75037e28b305a61580ffcad00930f02115773 differ diff --git a/fuzz/corpus/alloc_ops/ffef188f79bcacb7158d31bf03705400ada409d6 b/fuzz/corpus/alloc_ops/ffef188f79bcacb7158d31bf03705400ada409d6 new file mode 100644 index 0000000..9c71d1d Binary files /dev/null and b/fuzz/corpus/alloc_ops/ffef188f79bcacb7158d31bf03705400ada409d6 differ diff --git a/tools/gate-selftest.sh b/tools/gate-selftest.sh index faad2db..f928033 100644 --- a/tools/gate-selftest.sh +++ b/tools/gate-selftest.sh @@ -143,7 +143,7 @@ run_case "init_region refuses a misaligned exact region" "crates/rusty_alloc/s # Drop the header slice from the price and a 64 KiB request looks like it fits # one segment. That is the arithmetic a firmware sizes its region with, and the # defect the rusty_zstd report measured as one block served from four segments. -run_case "dedicated_segments prices the header slice" "crates/rusty_alloc/src/prim/fixed.rs" 's/\(crate::types::SEGMENT_SLICE_SIZE \+ size\)\.div_ceil/(size).div_ceil/' "--lib prim::fixed::tests::dedicated_segments" "--cfg ra_single_threaded --cfg ra_small_profile" +run_case "dedicated_segments prices the header slice" "crates/rusty_alloc/src/prim/fixed.rs" 's/slice\.checked_add\(size\)/size.checked_add(0)/' "--lib prim::fixed::tests::dedicated_segments" "--cfg ra_single_threaded --cfg ra_small_profile" echo if ((fail > 0)); then diff --git a/tools/unsafe-baseline.txt b/tools/unsafe-baseline.txt index 4617c86..c57726a 100644 --- a/tools/unsafe-baseline.txt +++ b/tools/unsafe-baseline.txt @@ -1,7 +1,7 @@ 94 crates/rusty_alloc/src/alloc.rs - 13 crates/rusty_alloc/src/arena.rs - 71 crates/rusty_alloc/src/heap.rs - 37 crates/rusty_alloc/src/init.rs + 15 crates/rusty_alloc/src/arena.rs + 73 crates/rusty_alloc/src/heap.rs + 42 crates/rusty_alloc/src/init.rs 2 crates/rusty_alloc/src/lib.rs 6 crates/rusty_alloc/src/options.rs 12 crates/rusty_alloc/src/os.rs @@ -9,15 +9,15 @@ 37 crates/rusty_alloc/src/prim/fixed.rs 8 crates/rusty_alloc/src/prim/mock.rs 17 crates/rusty_alloc/src/prim/mod.rs - 27 crates/rusty_alloc/src/prim/unix.rs + 28 crates/rusty_alloc/src/prim/unix.rs 6 crates/rusty_alloc/src/prim/wasm.rs - 30 crates/rusty_alloc/src/prim/windows.rs + 33 crates/rusty_alloc/src/prim/windows.rs 2 crates/rusty_alloc/src/random.rs 36 crates/rusty_alloc/src/segment.rs 3 crates/rusty_alloc/src/stats.rs 14 crates/rusty_alloc_api/src/lib.rs 15 crates/rusty_alloc_bench/src/kernels.rs 14 crates/rusty_alloc_bench/src/replay.rs - 350 crates/rusty_alloc_ffi/src/lib.rs + 356 crates/rusty_alloc_ffi/src/lib.rs 51 crates/rusty_alloc_override/src/lib.rs 26 crates/rusty_alloc_wasm/src/lib.rs diff --git a/tools/wasm-size-baseline.txt b/tools/wasm-size-baseline.txt index 5bcd8ca..1d8af61 100644 --- a/tools/wasm-size-baseline.txt +++ b/tools/wasm-size-baseline.txt @@ -1 +1 @@ -20169 +20321