does not work for me :-(

As a non-rust person I have no clue how to fix these ...
   Compiling c2rust_out v0.0.0 (/prg/tmp/AFLrustrust)
error[E0658]: non-builtin inner attributes are unstable
  --> c2rust-lib.rs:14:1
   |
14 | #![register_tool(c2rust)]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: for more information, see https://github.com/rust-lang/rust/issues/54726

error: cannot find attribute `register_tool` in this scope
  --> c2rust-lib.rs:14:4
   |
14 | #![register_tool(c2rust)]
   |    ^^^^^^^^^^^^^

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_as.rs:105:10
    |
105 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_as.rs:105:16
    |
105 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_as.rs:135:10
    |
135 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_as.rs:135:16
    |
135 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_as.rs:183:10
    |
183 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_as.rs:183:16
    |
183 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_common.rs:85:10
   |
85 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_common.rs:85:16
   |
85 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_common.rs:92:10
   |
92 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_common.rs:92:16
   |
92 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_common.rs:97:10
   |
97 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_common.rs:97:16
   |
97 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_common.rs:174:10
    |
174 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_common.rs:174:16
    |
174 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_forkserver.rs:143:10
    |
143 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_forkserver.rs:143:16
    |
143 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_forkserver.rs:179:10
    |
179 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_forkserver.rs:179:16
    |
179 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_forkserver.rs:245:10
    |
245 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_forkserver.rs:245:16
    |
245 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_forkserver.rs:252:10
    |
252 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_forkserver.rs:252:16
    |
252 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_forkserver.rs:314:10
    |
314 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_forkserver.rs:314:16
    |
314 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:132:10
    |
132 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:132:16
    |
132 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:193:10
    |
193 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:193:16
    |
193 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:231:10
    |
231 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:231:16
    |
231 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:325:10
    |
325 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:325:16
    |
325 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:334:10
    |
334 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:334:16
    |
334 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:360:10
    |
360 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:360:16
    |
360 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:378:10
    |
378 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:378:16
    |
378 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:395:10
    |
395 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:395:16
    |
395 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:423:10
    |
423 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:423:16
    |
423 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_bitmap.rs:656:10
    |
656 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_bitmap.rs:656:16
    |
656 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_fuzz_cmplog.rs:71:10
   |
71 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_fuzz_cmplog.rs:71:16
   |
71 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:132:10
    |
132 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:132:16
    |
132 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:143:10
    |
143 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:143:16
    |
143 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:149:10
    |
149 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:149:16
    |
149 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:181:10
    |
181 | #[derive(Copy, Clone, BitfieldStruct)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:181:16
    |
181 | #[derive(Copy, Clone, BitfieldStruct)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:218:10
    |
218 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:218:16
    |
218 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:312:10
    |
312 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:312:16
    |
312 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:321:10
    |
321 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:321:16
    |
321 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:347:10
    |
347 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:347:16
    |
347 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:361:10
    |
361 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:361:16
    |
361 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:378:10
    |
378 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:378:16
    |
378 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:406:10
    |
406 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:406:16
    |
406 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_cmplog.rs:639:10
    |
639 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_cmplog.rs:639:16
    |
639 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:120:10
    |
120 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:120:16
    |
120 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:173:10
    |
173 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:173:16
    |
173 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:234:10
    |
234 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:234:16
    |
234 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:272:10
    |
272 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:272:16
    |
272 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:308:10
    |
308 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:308:16
    |
308 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:331:10
    |
331 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:331:16
    |
331 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:408:10
    |
408 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:408:16
    |
408 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:417:10
    |
417 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:417:16
    |
417 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:443:10
    |
443 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:443:16
    |
443 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:450:10
    |
450 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:450:16
    |
450 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:467:10
    |
467 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:467:16
    |
467 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:495:10
    |
495 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:495:16
    |
495 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_extras.rs:728:10
    |
728 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_extras.rs:728:16
    |
728 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:222:10
    |
222 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:222:16
    |
222 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:228:10
    |
228 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:228:16
    |
228 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:275:10
    |
275 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:275:16
    |
275 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:336:10
    |
336 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:336:16
    |
336 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:374:10
    |
374 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:374:16
    |
374 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:626:10
    |
626 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:626:16
    |
626 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:642:10
    |
642 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:642:16
    |
642 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:648:10
    |
648 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:648:16
    |
648 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:657:10
    |
657 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:657:16
    |
657 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:669:10
    |
669 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:669:16
    |
669 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:676:10
    |
676 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:676:16
    |
676 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:682:10
    |
682 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:682:16
    |
682 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:689:10
    |
689 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:689:16
    |
689 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:695:10
    |
695 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:695:16
    |
695 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:701:10
    |
701 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:701:16
    |
701 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:710:10
    |
710 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:710:16
    |
710 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:717:10
    |
717 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:717:16
    |
717 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:724:10
    |
724 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:724:16
    |
724 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:731:10
    |
731 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:731:16
    |
731 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:739:10
    |
739 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:739:16
    |
739 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:748:10
    |
748 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:748:16
    |
748 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:771:10
    |
771 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:771:16
    |
771 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:791:10
    |
791 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:791:16
    |
791 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:796:10
    |
796 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:796:16
    |
796 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:862:10
    |
862 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:862:16
    |
862 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:871:10
    |
871 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:871:16
    |
871 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:878:10
    |
878 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:878:16
    |
878 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:904:10
    |
904 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:904:16
    |
904 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:918:10
    |
918 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:918:16
    |
918 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:935:10
    |
935 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:935:16
    |
935 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_init.rs:963:10
    |
963 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_init.rs:963:16
    |
963 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
    --> src/afl_fuzz_init.rs:1196:10
     |
1196 | #[derive(Copy, Clone)]
     |          ^^^^
     |
     = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
    --> src/afl_fuzz_init.rs:1196:16
     |
1196 | #[derive(Copy, Clone)]
     |                ^^^^^
     |
     = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:130:10
    |
130 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:130:16
    |
130 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:191:10
    |
191 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:191:16
    |
191 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:229:10
    |
229 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:229:16
    |
229 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:297:10
    |
297 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:297:16
    |
297 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:306:10
    |
306 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:306:16
    |
306 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:363:10
    |
363 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:363:16
    |
363 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:596:10
    |
596 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:596:16
    |
596 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:603:10
    |
603 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:603:16
    |
603 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:630:10
    |
630 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:630:16
    |
630 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_mutators.rs:647:10
    |
647 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_mutators.rs:647:16
    |
647 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:154:10
    |
154 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:154:16
    |
154 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:215:10
    |
215 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:215:16
    |
215 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:253:10
    |
253 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:253:16
    |
253 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:347:10
    |
347 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:347:16
    |
347 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:356:10
    |
356 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:356:16
    |
356 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:382:10
    |
382 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:382:16
    |
382 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:423:10
    |
423 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:423:16
    |
423 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:440:10
    |
440 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:440:16
    |
440 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:468:10
    |
468 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:468:16
    |
468 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_one.rs:701:10
    |
701 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_one.rs:701:16
    |
701 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:105:10
    |
105 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:105:16
    |
105 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:166:10
    |
166 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:166:16
    |
166 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:204:10
    |
204 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:204:16
    |
204 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:298:10
    |
298 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:298:16
    |
298 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:307:10
    |
307 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:307:16
    |
307 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:333:10
    |
333 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:333:16
    |
333 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:350:10
    |
350 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:350:16
    |
350 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:367:10
    |
367 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:367:16
    |
367 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:395:10
    |
395 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:395:16
    |
395 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_queue.rs:628:10
    |
628 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_queue.rs:628:16
    |
628 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:121:10
    |
121 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:121:16
    |
121 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:182:10
    |
182 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:182:16
    |
182 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:193:10
    |
193 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:193:16
    |
193 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:199:10
    |
199 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:199:16
    |
199 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:205:10
    |
205 | #[derive(Copy, Clone, BitfieldStruct)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:205:16
    |
205 | #[derive(Copy, Clone, BitfieldStruct)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:242:10
    |
242 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:242:16
    |
242 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:336:10
    |
336 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:336:16
    |
336 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:371:10
    |
371 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:371:16
    |
371 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:378:10
    |
378 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:378:16
    |
378 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:404:10
    |
404 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:404:16
    |
404 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:434:10
    |
434 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:434:16
    |
434 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:451:10
    |
451 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:451:16
    |
451 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:479:10
    |
479 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:479:16
    |
479 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:712:10
    |
712 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:712:16
    |
712 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_redqueen.rs:769:10
    |
769 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_redqueen.rs:769:16
    |
769 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:148:10
    |
148 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:148:16
    |
148 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:195:10
    |
195 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:195:16
    |
195 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:256:10
    |
256 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:256:16
    |
256 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:267:10
    |
267 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:267:16
    |
267 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:273:10
    |
273 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:273:16
    |
273 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:305:10
    |
305 | #[derive(Copy, Clone, BitfieldStruct)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:305:16
    |
305 | #[derive(Copy, Clone, BitfieldStruct)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:342:10
    |
342 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:342:16
    |
342 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:378:10
    |
378 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:378:16
    |
378 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:388:10
    |
388 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:388:16
    |
388 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:465:10
    |
465 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:465:16
    |
465 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:474:10
    |
474 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:474:16
    |
474 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:500:10
    |
500 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:500:16
    |
500 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:514:10
    |
514 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:514:16
    |
514 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:531:10
    |
531 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:531:16
    |
531 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:559:10
    |
559 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:559:16
    |
559 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_run.rs:792:10
    |
792 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_run.rs:792:16
    |
792 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_fuzz_state.rs:91:10
   |
91 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_fuzz_state.rs:91:16
   |
91 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:152:10
    |
152 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:152:16
    |
152 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:190:10
    |
190 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:190:16
    |
190 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:284:10
    |
284 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:284:16
    |
284 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:293:10
    |
293 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:293:16
    |
293 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:300:10
    |
300 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:300:16
    |
300 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:326:10
    |
326 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:326:16
    |
326 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:343:10
    |
343 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:343:16
    |
343 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:360:10
    |
360 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:360:16
    |
360 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:388:10
    |
388 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:388:16
    |
388 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_state.rs:621:10
    |
621 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_state.rs:621:16
    |
621 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:106:10
    |
106 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:106:16
    |
106 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:153:10
    |
153 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:153:16
    |
153 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:214:10
    |
214 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:214:16
    |
214 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:252:10
    |
252 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:252:16
    |
252 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:288:10
    |
288 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:288:16
    |
288 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:308:10
    |
308 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:308:16
    |
308 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:314:10
    |
314 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:314:16
    |
314 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:320:10
    |
320 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:320:16
    |
320 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:326:10
    |
326 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:326:16
    |
326 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:332:10
    |
332 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:332:16
    |
332 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:338:10
    |
338 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:338:16
    |
338 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:344:10
    |
344 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:344:16
    |
344 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:350:10
    |
350 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:350:16
    |
350 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:356:10
    |
356 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:356:16
    |
356 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:362:10
    |
362 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:362:16
    |
362 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:368:10
    |
368 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:368:16
    |
368 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:374:10
    |
374 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:374:16
    |
374 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:380:10
    |
380 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:380:16
    |
380 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:386:10
    |
386 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:386:16
    |
386 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:397:10
    |
397 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:397:16
    |
397 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:405:10
    |
405 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:405:16
    |
405 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:431:10
    |
431 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:431:16
    |
431 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:461:10
    |
461 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:461:16
    |
461 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:478:10
    |
478 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:478:16
    |
478 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:506:10
    |
506 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:506:16
    |
506 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_fuzz_stats.rs:739:10
    |
739 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_fuzz_stats.rs:739:16
    |
739 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_gotcpu.rs:45:10
   |
45 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_gotcpu.rs:45:16
   |
45 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_gotcpu.rs:81:10
   |
81 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_gotcpu.rs:81:16
   |
81 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:304:10
    |
304 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:304:16
    |
304 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:313:10
    |
313 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:313:16
    |
313 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:333:10
    |
333 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:333:16
    |
333 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:339:10
    |
339 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:339:16
    |
339 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:345:10
    |
345 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:345:16
    |
345 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:351:10
    |
351 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:351:16
    |
351 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:357:10
    |
357 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:357:16
    |
357 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:363:10
    |
363 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:363:16
    |
363 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:369:10
    |
369 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:369:16
    |
369 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:375:10
    |
375 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:375:16
    |
375 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:381:10
    |
381 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:381:16
    |
381 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:387:10
    |
387 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:387:16
    |
387 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:393:10
    |
393 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:393:16
    |
393 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:399:10
    |
399 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:399:16
    |
399 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:405:10
    |
405 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:405:16
    |
405 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_gotcpu.rs:411:10
    |
411 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_gotcpu.rs:411:16
    |
411 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> src/afl_sharedmem.rs:65:10
   |
65 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> src/afl_sharedmem.rs:65:16
   |
65 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:127:10
    |
127 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:127:16
    |
127 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:164:10
    |
164 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:164:16
    |
164 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:175:10
    |
175 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:175:16
    |
175 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:181:10
    |
181 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:181:16
    |
181 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:216:10
    |
216 | #[derive(Copy, Clone, BitfieldStruct)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:216:16
    |
216 | #[derive(Copy, Clone, BitfieldStruct)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:254:10
    |
254 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:254:16
    |
254 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:260:10
    |
260 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:260:16
    |
260 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
   --> src/afl_sharedmem.rs:275:10
    |
275 | #[derive(Copy, Clone)]
    |          ^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
   --> src/afl_sharedmem.rs:275:16
    |
275 | #[derive(Copy, Clone)]
    |                ^^^^^
    |
    = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Copy`
  --> test_instr.rs:27:10
   |
27 | #[derive(Copy, Clone)]
   |          ^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: cannot determine resolution for the derive macro `Clone`
  --> test_instr.rs:27:16
   |
27 | #[derive(Copy, Clone)]
   |                ^^^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error[E0554]: `#![feature]` may not be used on the stable release channel
 --> c2rust-lib.rs:8:1
  |
8 | #![feature(asm)]
  | ^^^^^^^^^^^^^^^^

error[E0554]: `#![feature]` may not be used on the stable release channel
 --> c2rust-lib.rs:9:1
  |
9 | #![feature(const_raw_ptr_to_usize_cast)]
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0554]: `#![feature]` may not be used on the stable release channel
  --> c2rust-lib.rs:10:1
   |
10 | #![feature(extern_types)]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0554]: `#![feature]` may not be used on the stable release channel
  --> c2rust-lib.rs:11:1
   |
11 | #![feature(main)]
   | ^^^^^^^^^^^^^^^^^

error[E0554]: `#![feature]` may not be used on the stable release channel
  --> c2rust-lib.rs:12:1
   |
12 | #![feature(ptr_wrapping_offset_from)]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0554]: `#![feature]` may not be used on the stable release channel
  --> c2rust-lib.rs:13:1
   |
13 | #![feature(register_tool)]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused `#[macro_use]` import
  --> c2rust-lib.rs:18:31
   |
18 | extern crate c2rust_bitfields;#[macro_use]
   |                               ^^^^^^^^^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: unnecessary parentheses around assigned value
   --> src/afl_as.rs:517:17
    |
517 | /                 ({
518 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
519 | |                      let mut _len: s32 =
520 | |                          snprintf(0 as *mut libc::c_char,
...   |
544 | |                      _tmp
545 | |                  })
    | |___________________^
    |
    = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
    |
517 |                 {
518 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
519 |                      let mut _len: s32 =
520 |                          snprintf(0 as *mut libc::c_char,
521 |                                   0 as libc::c_int as libc::c_ulong,
522 |                                   b"%s/.afl-%u-%u.s\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:551:25
    |
551 | /                         ({
552 | |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
553 | |                              let mut _len: s32 =
554 | |                                  snprintf(0 as *mut libc::c_char,
...   |
586 | |                              _tmp
587 | |                          })
    | |___________________________^
    |
help: remove these parentheses
    |
551 |                         {
552 |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
553 |                              let mut _len: s32 =
554 |                                  snprintf(0 as *mut libc::c_char,
555 |                                           0 as libc::c_int as libc::c_ulong,
556 |                                           b"%s%s%s\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:590:25
    |
590 | /                         ({
591 | |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
592 | |                              let mut _len: s32 =
593 | |                                  snprintf(0 as *mut libc::c_char,
...   |
627 | |                              _tmp
628 | |                          })
    | |___________________________^
    |
help: remove these parentheses
    |
590 |                         {
591 |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
592 |                              let mut _len: s32 =
593 |                                  snprintf(0 as *mut libc::c_char,
594 |                                           0 as libc::c_int as libc::c_ulong,
595 |                                           b"%s%s/%s%s\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:732:13
    |
732 | /             ({
733 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
734 | |                  let mut _len: s32 =
735 | |                      snprintf(0 as *mut libc::c_char,
...   |
757 | |                  _tmp
758 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
732 |             {
733 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
734 |                  let mut _len: s32 =
735 |                      snprintf(0 as *mut libc::c_char,
736 |                               0 as libc::c_int as libc::c_ulong,
737 |                               b"%s/afl-qemu-trace\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:779:13
    |
779 | /             ({
780 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
781 | |                  let mut _len: s32 =
782 | |                      snprintf(0 as *mut libc::c_char,
...   |
804 | |                  _tmp
805 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
779 |             {
780 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
781 |                  let mut _len: s32 =
782 |                      snprintf(0 as *mut libc::c_char,
783 |                               0 as libc::c_int as libc::c_ulong,
784 |                               b"%s/afl-qemu-trace\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:865:13
    |
865 | /             ({
866 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
867 | |                  let mut _len: s32 =
868 | |                      snprintf(0 as *mut libc::c_char,
...   |
890 | |                  _tmp
891 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
865 |             {
866 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
867 |                  let mut _len: s32 =
868 |                      snprintf(0 as *mut libc::c_char,
869 |                               0 as libc::c_int as libc::c_ulong,
870 |                               b"%s/afl-qemu-trace\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:904:13
    |
904 | /             ({
905 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
906 | |                  let mut _len: s32 =
907 | |                      snprintf(0 as *mut libc::c_char,
...   |
929 | |                  _tmp
930 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
904 |             {
905 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
906 |                  let mut _len: s32 =
907 |                      snprintf(0 as *mut libc::c_char,
908 |                               0 as libc::c_int as libc::c_ulong,
909 |                               b"%s/afl-wine-trace\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_common.rs:951:13
    |
951 | /             ({
952 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
953 | |                  let mut _len: s32 =
954 | |                      snprintf(0 as *mut libc::c_char,
...   |
976 | |                  _tmp
977 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
951 |             {
952 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
953 |                  let mut _len: s32 =
954 |                      snprintf(0 as *mut libc::c_char,
955 |                               0 as libc::c_int as libc::c_ulong,
956 |                               b"%s/afl-qemu-trace\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
    --> src/afl_common.rs:982:17
     |
982  | /                 ({
983  | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
984  | |                      let mut _len: s32 =
985  | |                          snprintf(0 as *mut libc::c_char,
...    |
1007 | |                      _tmp
1008 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
982  |                 {
983  |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
984  |                      let mut _len: s32 =
985  |                          snprintf(0 as *mut libc::c_char,
986  |                                   0 as libc::c_int as libc::c_ulong,
987  |                                   b"%s/afl-wine-trace\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_bitmap.rs:2101:13
     |
2101 | /             ({
2102 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2103 | |                  let mut _len: s32 =
2104 | |                      snprintf(0 as *mut libc::c_char,
...    |
2128 | |                  _tmp
2129 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
2101 |             {
2102 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2103 |                  let mut _len: s32 =
2104 |                      snprintf(0 as *mut libc::c_char,
2105 |                               0 as libc::c_int as libc::c_ulong,
2106 |                               b"%s/queue/id:%06u,%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_extras.rs:1367:17
     |
1367 | /                 ({
1368 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1369 | |                      let mut _len: s32 =
1370 | |                          snprintf(0 as *mut libc::c_char,
...    |
1394 | |                      _tmp
1395 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
1367 |                 {
1368 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1369 |                      let mut _len: s32 =
1370 |                          snprintf(0 as *mut libc::c_char,
1371 |                                   0 as libc::c_int as libc::c_ulong,
1372 |                                   b"%s/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_extras.rs:1781:13
     |
1781 | /             ({
1782 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1783 | |                  let mut _len: s32 =
1784 | |                      snprintf(0 as *mut libc::c_char,
...    |
1808 | |                  _tmp
1809 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
1781 |             {
1782 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1783 |                  let mut _len: s32 =
1784 |                      snprintf(0 as *mut libc::c_char,
1785 |                               0 as libc::c_int as libc::c_ulong,
1786 |                               b"%s/queue/.state/auto_extras/auto_%06u\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_extras.rs:1874:13
     |
1874 | /             ({
1875 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1876 | |                  let mut _len: s32 =
1877 | |                      snprintf(0 as *mut libc::c_char,
...    |
1900 | |                  _tmp
1901 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
1874 |             {
1875 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1876 |                  let mut _len: s32 =
1877 |                      snprintf(0 as *mut libc::c_char,
1878 |                               0 as libc::c_int as libc::c_ulong,
1879 |                               b"%s/.state/auto_extras/auto_%06u\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:1936:9
     |
1936 | /         ({
1937 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1938 | |              let mut _len: s32 =
1939 | |                  snprintf(0 as *mut libc::c_char,
...    |
1961 | |              _tmp
1962 | |          });
     | |___________^
     |
help: remove these parentheses
     |
1936 |         {
1937 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1938 |              let mut _len: s32 =
1939 |                  snprintf(0 as *mut libc::c_char,
1940 |                           0 as libc::c_int as libc::c_ulong,
1941 |                           b"%s/queue\x00" as *const u8 as *const libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:2027:13
     |
2027 | /             ({
2028 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2029 | |                  let mut _len: s32 =
2030 | |                      snprintf(0 as *mut libc::c_char,
...    |
2054 | |                  _tmp
2055 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
2027 |             {
2028 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2029 |                  let mut _len: s32 =
2030 |                      snprintf(0 as *mut libc::c_char,
2031 |                               0 as libc::c_int as libc::c_ulong,
2032 |                               b"%s/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:2515:17
     |
2515 | /                 ({
2516 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2517 | |                      let mut _len: s32 =
2518 | |                          snprintf(0 as *mut libc::c_char,
...    |
2541 | |                      _tmp
2542 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
2515 |                 {
2516 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2517 |                      let mut _len: s32 =
2518 |                          snprintf(0 as *mut libc::c_char,
2519 |                                   0 as libc::c_int as libc::c_ulong,
2520 |                                   b"%s/queue/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:2580:17
     |
2580 | /                 ({
2581 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2582 | |                      let mut _len: s32 =
2583 | |                          snprintf(0 as *mut libc::c_char,
...    |
2607 | |                      _tmp
2608 | |                  })
     | |___________________^
     |
help: remove these parentheses
     |
2580 |                 {
2581 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2582 |                      let mut _len: s32 =
2583 |                          snprintf(0 as *mut libc::c_char,
2584 |                                   0 as libc::c_int as libc::c_ulong,
2585 |                                   b"%s/queue/id:%06u,time:0,orig:%s\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:2814:13
     |
2814 | /             ({
2815 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2816 | |                  let mut _len: s32 =
2817 | |                      snprintf(0 as *mut libc::c_char,
...    |
2839 | |                  _tmp
2840 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
2814 |             {
2815 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2816 |                  let mut _len: s32 =
2817 |                      snprintf(0 as *mut libc::c_char,
2818 |                               0 as libc::c_int as libc::c_ulong,
2819 |                               b"%s/fuzzer_stats\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:2843:13
     |
2843 | /             ({
2844 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2845 | |                  let mut _len: s32 =
2846 | |                      snprintf(0 as *mut libc::c_char,
...    |
2868 | |                  _tmp
2869 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
2843 |             {
2844 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
2845 |                  let mut _len: s32 =
2846 |                      snprintf(0 as *mut libc::c_char,
2847 |                               0 as libc::c_int as libc::c_ulong,
2848 |                               b"%s/../fuzzer_stats\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3085:13
     |
3085 | /             ({
3086 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3087 | |                  let mut _len: s32 =
3088 | |                      snprintf(0 as *mut libc::c_char,
...    |
3110 | |                  _tmp
3111 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
3085 |             {
3086 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3087 |                  let mut _len: s32 =
3088 |                      snprintf(0 as *mut libc::c_char,
3089 |                               0 as libc::c_int as libc::c_ulong,
3090 |                               b"%s/fuzzer_stats\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3114:13
     |
3114 | /             ({
3115 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3116 | |                  let mut _len: s32 =
3117 | |                      snprintf(0 as *mut libc::c_char,
...    |
3139 | |                  _tmp
3140 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
3114 |             {
3115 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3116 |                  let mut _len: s32 =
3117 |                      snprintf(0 as *mut libc::c_char,
3118 |                               0 as libc::c_int as libc::c_ulong,
3119 |                               b"%s/../fuzzer_stats\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3182:17
     |
3182 | /                 ({
3183 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3184 | |                      let mut _len: s32 =
3185 | |                          snprintf(0 as *mut libc::c_char,
...    |
3209 | |                      _tmp
3210 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
3182 |                 {
3183 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3184 |                      let mut _len: s32 =
3185 |                          snprintf(0 as *mut libc::c_char,
3186 |                                   0 as libc::c_int as libc::c_ulong,
3187 |                                   b"%s/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3285:9
     |
3285 | /         ({
3286 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3287 | |              let mut _len: s32 =
3288 | |                  snprintf(0 as *mut libc::c_char,
...    |
3311 | |              _tmp
3312 | |          });
     | |___________^
     |
help: remove these parentheses
     |
3285 |         {
3286 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3287 |              let mut _len: s32 =
3288 |                  snprintf(0 as *mut libc::c_char,
3289 |                           0 as libc::c_int as libc::c_ulong,
3290 |                           b"%s/_resume/.state/deterministic_done\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3318:13
     |
3318 | /             ({
3319 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3320 | |                  let mut _len: s32 =
3321 | |                      snprintf(0 as *mut libc::c_char,
...    |
3344 | |                  _tmp
3345 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
3318 |             {
3319 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3320 |                  let mut _len: s32 =
3321 |                      snprintf(0 as *mut libc::c_char,
3322 |                               0 as libc::c_int as libc::c_ulong,
3323 |                               b"%s/_resume/.state/auto_extras\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3351:17
     |
3351 | /                 ({
3352 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3353 | |                      let mut _len: s32 =
3354 | |                          snprintf(0 as *mut libc::c_char,
...    |
3378 | |                      _tmp
3379 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
3351 |                 {
3352 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3353 |                      let mut _len: s32 =
3354 |                          snprintf(0 as *mut libc::c_char,
3355 |                                   0 as libc::c_int as libc::c_ulong,
3356 |                                   b"%s/_resume/.state/redundant_edges\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3385:21
     |
3385 | /                     ({
3386 | |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3387 | |                          let mut _len: s32 =
3388 | |                              snprintf(0 as *mut libc::c_char,
...    |
3413 | |                          _tmp
3414 | |                      });
     | |_______________________^
     |
help: remove these parentheses
     |
3385 |                     {
3386 |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3387 |                          let mut _len: s32 =
3388 |                              snprintf(0 as *mut libc::c_char,
3389 |                                       0 as libc::c_int as libc::c_ulong,
3390 |                                       b"%s/_resume/.state/variable_behavior\x00"
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3421:25
     |
3421 | /                         ({
3422 | |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3423 | |                              let mut _len: s32 =
3424 | |                                  snprintf(0 as *mut libc::c_char,
...    |
3453 | |                              _tmp
3454 | |                          });
     | |___________________________^
     |
help: remove these parentheses
     |
3421 |                         {
3422 |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3423 |                              let mut _len: s32 =
3424 |                                  snprintf(0 as *mut libc::c_char,
3425 |                                           0 as libc::c_int as libc::c_ulong,
3426 |                                           b"%s/_resume/.state\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3459:29
     |
3459 | / ...                   ({
3460 | | ...                        let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3461 | | ...                        let mut _len: s32 =
3462 | | ...                            snprintf(0 as *mut libc::c_char,
...    |
3492 | | ...                        _tmp
3493 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
3459 |                             {
3460 |                                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3461 |                                  let mut _len: s32 =
3462 |                                      snprintf(0 as *mut libc::c_char,
3463 |                                               0 as libc::c_int as
3464 |                                                   libc::c_ulong,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3522:9
     |
3522 | /         ({
3523 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3524 | |              let mut _len: s32 =
3525 | |                  snprintf(0 as *mut libc::c_char,
...    |
3547 | |              _tmp
3548 | |          });
     | |___________^
     |
help: remove these parentheses
     |
3522 |         {
3523 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3524 |              let mut _len: s32 =
3525 |                  snprintf(0 as *mut libc::c_char,
3526 |                           0 as libc::c_int as libc::c_ulong,
3527 |                           b"%s/fuzzer_stats\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3642:13
     |
3642 | /             ({
3643 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0; /* Ignore errors */
3644 | |                  let mut _len: s32 =
3645 | |                      snprintf(0 as *mut libc::c_char,
...    |
3667 | |                  _tmp
3668 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
3642 |             {
3643 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0; /* Ignore errors */
3644 |                  let mut _len: s32 =
3645 |                      snprintf(0 as *mut libc::c_char,
3646 |                               0 as libc::c_int as libc::c_ulong,
3647 |                               b"%s/queue\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3670:13
     |
3670 | /             ({
3671 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3672 | |                  let mut _len: s32 =
3673 | |                      snprintf(0 as *mut libc::c_char,
...    |
3695 | |                  _tmp
3696 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
3670 |             {
3671 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3672 |                  let mut _len: s32 =
3673 |                      snprintf(0 as *mut libc::c_char,
3674 |                               0 as libc::c_int as libc::c_ulong,
3675 |                               b"%s/_resume\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3715:13
     |
3715 | /             ({
3716 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3717 | |                  let mut _len: s32 =
3718 | |                      snprintf(0 as *mut libc::c_char,
...    |
3740 | |                  _tmp
3741 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
3715 |             {
3716 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3717 |                  let mut _len: s32 =
3718 |                      snprintf(0 as *mut libc::c_char,
3719 |                               0 as libc::c_int as libc::c_ulong,
3720 |                               b"%s/.synced\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3753:17
     |
3753 | /                 ({
3754 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3755 | |                      let mut _len: s32 =
3756 | |                          snprintf(0 as *mut libc::c_char,
...    |
3780 | |                      _tmp
3781 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
3753 |                 {
3754 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3755 |                      let mut _len: s32 =
3756 |                          snprintf(0 as *mut libc::c_char,
3757 |                                   0 as libc::c_int as libc::c_ulong,
3758 |                                   b"%s/queue/.state/deterministic_done\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3787:21
     |
3787 | /                     ({
3788 | |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3789 | |                          let mut _len: s32 =
3790 | |                              snprintf(0 as *mut libc::c_char,
...    |
3815 | |                          _tmp
3816 | |                      });
     | |_______________________^
     |
help: remove these parentheses
     |
3787 |                     {
3788 |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3789 |                          let mut _len: s32 =
3790 |                              snprintf(0 as *mut libc::c_char,
3791 |                                       0 as libc::c_int as libc::c_ulong,
3792 |                                       b"%s/queue/.state/auto_extras\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3823:25
     |
3823 | /                         ({
3824 | |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3825 | |                              let mut _len: s32 =
3826 | |                                  snprintf(0 as *mut libc::c_char,
...    |
3855 | |                              _tmp
3856 | |                          });
     | |___________________________^
     |
help: remove these parentheses
     |
3823 |                         {
3824 |                              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3825 |                              let mut _len: s32 =
3826 |                                  snprintf(0 as *mut libc::c_char,
3827 |                                           0 as libc::c_int as libc::c_ulong,
3828 |                                           b"%s/queue/.state/redundant_edges\x00"
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3863:29
     |
3863 | / ...                   ({
3864 | | ...                        let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3865 | | ...                        let mut _len: s32 =
3866 | | ...                            snprintf(0 as *mut libc::c_char,
...    |
3898 | | ...                        _tmp
3899 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
3863 |                             {
3864 |                                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3865 |                                  let mut _len: s32 =
3866 |                                      snprintf(0 as *mut libc::c_char,
3867 |                                               0 as libc::c_int as
3868 |                                                   libc::c_ulong,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3908:33
     |
3908 | / ...                   ({