does not work for me :-(

[vanhauser-thc]

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 | / ...                   ({
3909 | | ...                        let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3910 | | ...                        let mut _len: s32 =
3911 | | ...                            snprintf(0 as *mut libc::c_char,
...    |
3946 | | ...                        _tmp
3947 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
3908 |                                 {
3909 |                                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
3910 |                                      let mut _len: s32 =
3911 |                                          snprintf(0 as *mut libc::c_char,
3912 |                                                   0 as libc::c_int as
3913 |                                                       libc::c_ulong,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:3953:37
     |
3953 | / ...                   ({
3954 | | ...                        let mut _tmp: *mut u8_0 =
3955 | | ...                            0 as *mut u8_0;
3956 | | ...                        let mut _len: s32 =
...    |
3992 | | ...                        _tmp
3993 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
3953 |                                     {
3954 |                                          let mut _tmp: *mut u8_0 =
3955 |                                              0 as *mut u8_0;
3956 |                                          let mut _len: s32 =
3957 |                                              snprintf(0 as *mut libc::c_char,
3958 |                                                       0 as libc::c_int as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4003:45
     |
4003 | / ...                   ({
4004 | | ...                        let mut _tmp: *mut u8_0 =
4005 | | ...                            0 as
4006 | | ...                                *mut u8_0; /* Ignore errors */
...    |
4057 | | ...                        _tmp
4058 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4003 |                                             {
4004 |                                                  let mut _tmp: *mut u8_0 =
4005 |                                                      0 as
4006 |                                                          *mut u8_0; /* Ignore errors */
4007 |                                                  let mut _len: s32 =
4008 |                                                      snprintf(0 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4064:41
     |
4064 | / ...                   ({
4065 | | ...                        let mut _tmp: *mut u8_0 =
4066 | | ...                            0 as *mut u8_0;
4067 | | ...                        let mut _len: s32 =
...    |
4107 | | ...                        _tmp
4108 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4064 |                                         {
4065 |                                              let mut _tmp: *mut u8_0 =
4066 |                                                  0 as *mut u8_0;
4067 |                                              let mut _len: s32 =
4068 |                                                  snprintf(0 as
4069 |                                                               *mut libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4120:45
     |
4120 | / ...                   ({
4121 | | ...                        let mut _tmp: *mut u8_0 =
4122 | | ...                            0 as *mut u8_0;
4123 | | ...                        let mut _len: s32 =
...    |
4193 | | ...                        _tmp
4194 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4120 |                                             {
4121 |                                                  let mut _tmp: *mut u8_0 =
4122 |                                                      0 as *mut u8_0;
4123 |                                                  let mut _len: s32 =
4124 |                                                      snprintf(0 as
4125 |                                                                   *mut libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4210:45
     |
4210 | / ...                   ({
4211 | | ...                        let mut _tmp: *mut u8_0 =
4212 | | ...                            0 as *mut u8_0;
4213 | | ...                        let mut _len: s32 =
...    |
4263 | | ...                        _tmp
4264 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4210 |                                             {
4211 |                                                  let mut _tmp: *mut u8_0 =
4212 |                                                      0 as *mut u8_0;
4213 |                                                  let mut _len: s32 =
4214 |                                                      snprintf(0 as
4215 |                                                                   *mut libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4276:49
     |
4276 | / ...                   ({
4277 | | ...                        let mut _tmp: *mut u8_0 =
4278 | | ...                            0 as *mut u8_0;
4279 | | ...                        let mut _len: s32 =
...    |
4361 | | ...                        _tmp
4362 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4276 |                                                 {
4277 |                                                      let mut _tmp: *mut u8_0 =
4278 |                                                          0 as *mut u8_0;
4279 |                                                      let mut _len: s32 =
4280 |                                                          snprintf(0 as
4281 |                                                                       *mut libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4383:53
     |
4383 | / ...                   ({
4384 | | ...                        let mut _tmp:
4385 | | ...                                *mut u8_0 =
4386 | | ...                            0 as *mut u8_0;
...    |
4453 | | ...                        _tmp
4454 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
4383 |                                                     {
4384 |                                                          let mut _tmp:
4385 |                                                                  *mut u8_0 =
4386 |                                                              0 as *mut u8_0;
4387 |                                                          let mut _len: s32 =
4388 |                                                              snprintf(0 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4457:53
     |
4457 | / ...                   ({
4458 | | ...                        let mut _tmp:
4459 | | ...                                *mut u8_0 =
4460 | | ...                            0 as *mut u8_0;
...    |
4525 | | ...                        _tmp
4526 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
4457 |                                                     {
4458 |                                                          let mut _tmp:
4459 |                                                                  *mut u8_0 =
4460 |                                                              0 as *mut u8_0;
4461 |                                                          let mut _len: s32 =
4462 |                                                              snprintf(0 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4536:53
     |
4536 | / ...                   ({
4537 | | ...                        let mut _tmp:
4538 | | ...                                *mut u8_0 =
4539 | | ...                            0 as *mut u8_0;
...    |
4604 | | ...                        _tmp
4605 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4536 |                                                     {
4537 |                                                          let mut _tmp:
4538 |                                                                  *mut u8_0 =
4539 |                                                              0 as *mut u8_0;
4540 |                                                          let mut _len: s32 =
4541 |                                                              snprintf(0 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4618:61
     |
4618 | / ...                   ({
4619 | | ...                        let mut _tmp:
4620 | | ...                                *mut u8_0 =
4621 | | ...                            0 as
...    |
4695 | | ...                        _tmp
4696 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4618 |                                                             {
4619 |                                                                  let mut _tmp:
4620 |                                                                          *mut u8_0 =
4621 |                                                                      0 as
4622 |                                                                          *mut u8_0;
4623 |                                                                  let mut _len:
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4724:65
     |
4724 | / ...                   ({
4725 | | ...                        let mut _tmp:
4726 | | ...                                *mut u8_0 =
4727 | | ...                            0 as
...    |
4803 | | ...                        _tmp
4804 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4724 |                                                                 {
4725 |                                                                      let mut _tmp:
4726 |                                                                              *mut u8_0 =
4727 |                                                                          0 as
4728 |                                                                              *mut u8_0;
4729 |                                                                      let mut _len:
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:4818:69
     |
4818 | / ...                   ({
4819 | | ...                        let mut _tmp:
4820 | | ...                                *mut u8_0 =
4821 | | ...                            0
...    |
4900 | | ...                        _tmp
4901 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4818 |                                                                     {
4819 |                                                                          let mut _tmp:
4820 |                                                                                  *mut u8_0 =
4821 |                                                                              0
4822 |                                                                                  as
4823 |                                                                                  *mut u8_0;
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5030:9
     |
5030 | /         ({
5031 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5032 | |              let mut _len: s32 =
5033 | |                  snprintf(0 as *mut libc::c_char,
...    |
5055 | |              _tmp
5056 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5030 |         {
5031 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5032 |              let mut _len: s32 =
5033 |                  snprintf(0 as *mut libc::c_char,
5034 |                           0 as libc::c_int as libc::c_ulong,
5035 |                           b"%s/queue\x00" as *const u8 as *const libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5075:9
     |
5075 | /         ({
5076 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5077 | |              let mut _len: s32 =
5078 | |                  snprintf(0 as *mut libc::c_char,
...    |
5100 | |              _tmp
5101 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5075 |         {
5076 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5077 |              let mut _len: s32 =
5078 |                  snprintf(0 as *mut libc::c_char,
5079 |                           0 as libc::c_int as libc::c_ulong,
5080 |                           b"%s/queue/.state/\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5120:9
     |
5120 | /         ({
5121 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5122 | |              let mut _len: s32 =
5123 | |                  snprintf(0 as *mut libc::c_char,
...    |
5146 | |              _tmp
5147 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5120 |         {
5121 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5122 |              let mut _len: s32 =
5123 |                  snprintf(0 as *mut libc::c_char,
5124 |                           0 as libc::c_int as libc::c_ulong,
5125 |                           b"%s/queue/.state/deterministic_done/\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5165:9
     |
5165 | /         ({
5166 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5167 | |              let mut _len: s32 =
5168 | |                  snprintf(0 as *mut libc::c_char,
...    |
5190 | |              _tmp
5191 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5165 |         {
5166 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5167 |              let mut _len: s32 =
5168 |                  snprintf(0 as *mut libc::c_char,
5169 |                           0 as libc::c_int as libc::c_ulong,
5170 |                           b"%s/queue/.state/auto_extras/\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5209:9
     |
5209 | /         ({
5210 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5211 | |              let mut _len: s32 =
5212 | |                  snprintf(0 as *mut libc::c_char,
...    |
5234 | |              _tmp
5235 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5209 |         {
5210 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5211 |              let mut _len: s32 =
5212 |                  snprintf(0 as *mut libc::c_char,
5213 |                           0 as libc::c_int as libc::c_ulong,
5214 |                           b"%s/queue/.state/redundant_edges/\x00" as *const u8
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5253:9
     |
5253 | /         ({
5254 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5255 | |              let mut _len: s32 =
5256 | |                  snprintf(0 as *mut libc::c_char,
...    |
5279 | |              _tmp
5280 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5253 |         {
5254 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5255 |              let mut _len: s32 =
5256 |                  snprintf(0 as *mut libc::c_char,
5257 |                           0 as libc::c_int as libc::c_ulong,
5258 |                           b"%s/queue/.state/variable_behavior/\x00" as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5299:13
     |
5299 | /             ({
5300 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5301 | |                  let mut _len: s32 =
5302 | |                      snprintf(0 as *mut libc::c_char,
...    |
5324 | |                  _tmp
5325 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
5299 |             {
5300 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5301 |                  let mut _len: s32 =
5302 |                      snprintf(0 as *mut libc::c_char,
5303 |                               0 as libc::c_int as libc::c_ulong,
5304 |                               b"%s/.synced/\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5347:9
     |
5347 | /         ({
5348 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5349 | |              let mut _len: s32 =
5350 | |                  snprintf(0 as *mut libc::c_char,
...    |
5372 | |              _tmp
5373 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5347 |         {
5348 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5349 |              let mut _len: s32 =
5350 |                  snprintf(0 as *mut libc::c_char,
5351 |                           0 as libc::c_int as libc::c_ulong,
5352 |                           b"%s/crashes\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5391:9
     |
5391 | /         ({
5392 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5393 | |              let mut _len: s32 =
5394 | |                  snprintf(0 as *mut libc::c_char,
...    |
5416 | |              _tmp
5417 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5391 |         {
5392 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5393 |              let mut _len: s32 =
5394 |                  snprintf(0 as *mut libc::c_char,
5395 |                           0 as libc::c_int as libc::c_ulong,
5396 |                           b"%s/hangs\x00" as *const u8 as *const libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5468:9
     |
5468 | /         ({
5469 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5470 | |              let mut _len: s32 =
5471 | |                  snprintf(0 as *mut libc::c_char,
...    |
5493 | |              _tmp
5494 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5468 |         {
5469 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5470 |              let mut _len: s32 =
5471 |                  snprintf(0 as *mut libc::c_char,
5472 |                           0 as libc::c_int as libc::c_ulong,
5473 |                           b"%s/plot_data\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5543:9
     |
5543 | /         ({
5544 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5545 | |              let mut _len: s32 =
5546 | |                  snprintf(0 as *mut libc::c_char,
...    |
5568 | |              _tmp
5569 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5543 |         {
5544 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5545 |              let mut _len: s32 =
5546 |                  snprintf(0 as *mut libc::c_char,
5547 |                           0 as libc::c_int as libc::c_ulong,
5548 |                           b"%s/cmdline\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5615:13
     |
5615 | /             ({
5616 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5617 | |                  let mut _len: s32 =
5618 | |                      snprintf(0 as *mut libc::c_char,
...    |
5642 | |                  _tmp
5643 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
5615 |             {
5616 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5617 |                  let mut _len: s32 =
5618 |                      snprintf(0 as *mut libc::c_char,
5619 |                               0 as libc::c_int as libc::c_ulong,
5620 |                               b"%s/.cur_input.%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5646:13
     |
5646 | /             ({
5647 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5648 | |                  let mut _len: s32 =
5649 | |                      snprintf(0 as *mut libc::c_char,
...    |
5671 | |                  _tmp
5672 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
5646 |             {
5647 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5648 |                  let mut _len: s32 =
5649 |                      snprintf(0 as *mut libc::c_char,
5650 |                               0 as libc::c_int as libc::c_ulong,
5651 |                               b"%s/.cur_input\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:5937:9
     |
5937 | /         ({
5938 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5939 | |              let mut _len: s32 =
5940 | |                  snprintf(0 as *mut libc::c_char,
...    |
5962 | |              _tmp
5963 | |          });
     | |___________^
     |
help: remove these parentheses
     |
5937 |         {
5938 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
5939 |              let mut _len: s32 =
5940 |                  snprintf(0 as *mut libc::c_char,
5941 |                           0 as libc::c_int as libc::c_ulong,
5942 |                           b"%s/%s\x00" as *const u8 as *const libc::c_char,
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_init.rs:6183:21
     |
6183 | /                     ({
6184 | |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
6185 | |                          let mut _len: s32 =
6186 | |                              snprintf(0 as *mut libc::c_char,
...    |
6210 | |                          _tmp
6211 | |                      })
     | |_______________________^
     |
help: remove these parentheses
     |
6183 |                     {
6184 |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
6185 |                          let mut _len: s32 =
6186 |                              snprintf(0 as *mut libc::c_char,
6187 |                                       0 as libc::c_int as libc::c_ulong,
6188 |                                       b"%s/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:1243:13
     |
1243 | /             ({
1244 | |                  let mut _ret: u32_0 = new_val;
1245 | |                  (_ret << 24 as libc::c_int | _ret >> 24 as libc::c_int |
1246 | |                       _ret << 8 as libc::c_int &
...    |
1249 | |                          0xff00 as libc::c_int as libc::c_uint
1250 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
1243 |             {
1244 |                  let mut _ret: u32_0 = new_val;
1245 |                  (_ret << 24 as libc::c_int | _ret >> 24 as libc::c_int |
1246 |                       _ret << 8 as libc::c_int &
1247 |                           0xff0000 as libc::c_int as libc::c_uint) |
1248 |                      _ret >> 8 as libc::c_int &
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:1252:13
     |
1252 | /             ({
1253 | |                  let mut _ret: u32_0 = old_val;
1254 | |                  (_ret << 24 as libc::c_int | _ret >> 24 as libc::c_int |
1255 | |                       _ret << 8 as libc::c_int &
...    |
1258 | |                          0xff00 as libc::c_int as libc::c_uint
1259 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
1252 |             {
1253 |                  let mut _ret: u32_0 = old_val;
1254 |                  (_ret << 24 as libc::c_int | _ret >> 24 as libc::c_int |
1255 |                       _ret << 8 as libc::c_int &
1256 |                           0xff0000 as libc::c_int as libc::c_uint) |
1257 |                      _ret >> 8 as libc::c_int &
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:4066:121
     |
4066 | / ...                   ({
4067 | | ...                        let mut _ret:
4068 | | ...                                u16_0 =
4069 | | ...                            (({
...    |
4113 | | ...                            u16_0
4114 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4066 |                                                                                                                         {
4067 |                                                                                                                              let mut _ret:
4068 |                                                                                                                                      u16_0 =
4069 |                                                                                                                                  (({
4070 |                                                                                                                                        let mut _ret_0:
4071 |                                                                                                                                                u16_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:4163:121
     |
4163 | / ...                   ({
4164 | | ...                        let mut _ret:
4165 | | ...                                u16_0 =
4166 | | ...                            (({
...    |
4210 | | ...                            u16_0
4211 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4163 |                                                                                                                         {
4164 |                                                                                                                              let mut _ret:
4165 |                                                                                                                                      u16_0 =
4166 |                                                                                                                                  (({
4167 |                                                                                                                                        let mut _ret_0:
4168 |                                                                                                                                                u16_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:4834:133
     |
4834 | / ...                   ({
4835 | | ...                        let mut _ret:
4836 | | ...                                u32_0 =
4837 | | ...                            ({
...    |
4913 | | ...                                    libc::c_uint
4914 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
4834 |                                                                                                                                     {
4835 |                                                                                                                                          let mut _ret:
4836 |                                                                                                                                                  u32_0 =
4837 |                                                                                                                                              ({
4838 |                                                                                                                                                   let mut _ret_0:
4839 |                                                                                                                                                           u32_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:5002:133
     |
5002 | / ...                   ({
5003 | | ...                        let mut _ret:
5004 | | ...                                u32_0 =
5005 | | ...                            ({
...    |
5081 | | ...                                    libc::c_uint
5082 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
5002 |                                                                                                                                     {
5003 |                                                                                                                                          let mut _ret:
5004 |                                                                                                                                                  u32_0 =
5005 |                                                                                                                                              ({
5006 |                                                                                                                                                   let mut _ret_0:
5007 |                                                                                                                                                           u32_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:5870:125
     |
5870 | / ...                   ({
5871 | | ...                        let mut _ret:
5872 | | ...                                u16_0 =
5873 | | ...                            interesting_16[j
...    |
5894 | | ...                            u16_0
5895 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
5870 |                                                                                                                             {
5871 |                                                                                                                                  let mut _ret:
5872 |                                                                                                                                          u16_0 =
5873 |                                                                                                                                      interesting_16[j
5874 |                                                                                                                                                         as
5875 |                                                                                                                                                         usize]
   ...

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_one.rs:6353:151
     |
6353 | / ...                   ({
6354 | | ...                        let mut _ret:
6355 | | ...                                u32_0 =
6356 | | ...                            interesting_32[j
...    |
6395 | | ...                                    libc::c_uint
6396 | | ...                    }),
     | |_________________________^
     |
help: remove these parentheses
     |
6353 |                                                                                                                                                       {
6354 |                                                                                                                                                            let mut _ret:
6355 |                                                                                                                                                                    u32_0 =
6356 |                                                                                                                                                                interesting_32[j
6357 |                                                                                                                                                                                   as
6358 |                                                                                                                                                                                   usize]
   ...

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_one.rs:6406:154
     |
6406 | / ...                   ({
6407 | | ...                        let mut _ret:
6408 | | ...                                u32_0 =
6409 | | ...                            interesting_32[j
...    |
6448 | | ...                                    libc::c_uint
6449 | | ...                    }),
     | |_________________________^
     |
help: remove these parentheses
     |
6406 |                                                                                                                                                          {
6407 |                                                                                                                                                               let mut _ret:
6408 |                                                                                                                                                                       u32_0 =
6409 |                                                                                                                                                                   interesting_32[j
6410 |                                                                                                                                                                                      as
6411 |                                                                                                                                                                                      usize]
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:6476:137
     |
6476 | / ...                   ({
6477 | | ...                        let mut _ret:
6478 | | ...                                u32_0 =
6479 | | ...                            interesting_32[j
...    |
6518 | | ...                                    libc::c_uint
6519 | | ...                    });
     | |_________________________^
     |
help: remove these parentheses
     |
6476 |                                                                                                                                         {
6477 |                                                                                                                                              let mut _ret:
6478 |                                                                                                                                                      u32_0 =
6479 |                                                                                                                                                  interesting_32[j
6480 |                                                                                                                                                                     as
6481 |                                                                                                                                                                     usize]
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:8453:81
     |
8453 | / ...                   ({
8454 | | ...                        let mut _ret:
8455 | | ...                                u16_0 =
8456 | | ...                            interesting_16[rand_below(afl,
...    |
8486 | | ...                            u16_0
8487 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
8453 |                                                                                 {
8454 |                                                                                      let mut _ret:
8455 |                                                                                              u16_0 =
8456 |                                                                                          interesting_16[rand_below(afl,
8457 |                                                                                                                    (::std::mem::size_of::<[s16; 19]>()
8458 |                                                                                                                         as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:8549:81
     |
8549 | / ...                   ({
8550 | | ...                        let mut _ret:
8551 | | ...                                u32_0 =
8552 | | ...                            interesting_32[rand_below(afl,
...    |
8600 | | ...                                    libc::c_uint
8601 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
8549 |                                                                                 {
8550 |                                                                                      let mut _ret:
8551 |                                                                                              u32_0 =
8552 |                                                                                          interesting_32[rand_below(afl,
8553 |                                                                                                                    (::std::mem::size_of::<[s32; 27]>()
8554 |                                                                                                                         as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:8741:81
     |
8741 | / ...                   ({
8742 | | ...                        let mut _ret:
8743 | | ...                                u16_0 =
8744 | | ...                            (({
...    |
8794 | | ...                            u16_0
8795 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
8741 |                                                                                 {
8742 |                                                                                      let mut _ret:
8743 |                                                                                              u16_0 =
8744 |                                                                                          (({
8745 |                                                                                                let mut _ret_0:
8746 |                                                                                                        u16_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:8881:81
     |
8881 | / ...                   ({
8882 | | ...                        let mut _ret:
8883 | | ...                                u16_0 =
8884 | | ...                            (({
...    |
8934 | | ...                            u16_0
8935 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
8881 |                                                                                 {
8882 |                                                                                      let mut _ret:
8883 |                                                                                              u16_0 =
8884 |                                                                                          (({
8885 |                                                                                                let mut _ret_0:
8886 |                                                                                                        u16_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:9019:81
     |
9019 | / ...                   ({
9020 | | ...                        let mut _ret:
9021 | | ...                                u32_0 =
9022 | | ...                            ({
...    |
9100 | | ...                                    libc::c_uint
9101 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
9019 |                                                                                 {
9020 |                                                                                      let mut _ret:
9021 |                                                                                              u32_0 =
9022 |                                                                                          ({
9023 |                                                                                               let mut _ret_0:
9024 |                                                                                                       u32_0 =
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_one.rs:9185:81
     |
9185 | / ...                   ({
9186 | | ...                        let mut _ret:
9187 | | ...                                u32_0 =
9188 | | ...                            ({
...    |
9266 | | ...                                    libc::c_uint
9267 | | ...                    })
     | |_________________________^
     |
help: remove these parentheses
     |
9185 |                                                                                 {
9186 |                                                                                      let mut _ret:
9187 |                                                                                              u32_0 =
9188 |                                                                                          ({
9189 |                                                                                               let mut _ret_0:
9190 |                                                                                                       u32_0 =
   ...

warning: unnecessary parentheses around function argument
     --> src/afl_fuzz_one.rs:10479:74
      |
10479 | / ...                   ({
10480 | | ...                        let mut _a:
10481 | | ...                                s32 =
10482 | | ...                            len;
...     |
10497 | | ...                        }
10498 | | ...                    }),
      | |_________________________^
      |
help: remove these parentheses
      |
10479 |                                                                          {
10480 |                                                                               let mut _a:
10481 |                                                                                       s32 =
10482 |                                                                                   len;
10483 |                                                                               let mut _b:
10484 |                                                                                       u32_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:13055:109
      |
13055 | / ...                   ({
13056 | | ...                        let mut _ret:
13057 | | ...                                u16_0 =
13058 | | ...                            (({
...     |
13102 | | ...                            u16_0
13103 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
13055 |                                                                                                             {
13056 |                                                                                                                  let mut _ret:
13057 |                                                                                                                          u16_0 =
13058 |                                                                                                                      (({
13059 |                                                                                                                            let mut _ret_0:
13060 |                                                                                                                                    u16_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:13152:109
      |
13152 | / ...                   ({
13153 | | ...                        let mut _ret:
13154 | | ...                                u16_0 =
13155 | | ...                            (({
...     |
13199 | | ...                            u16_0
13200 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
13152 |                                                                                                             {
13153 |                                                                                                                  let mut _ret:
13154 |                                                                                                                          u16_0 =
13155 |                                                                                                                      (({
13156 |                                                                                                                            let mut _ret_0:
13157 |                                                                                                                                    u16_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:13823:121
      |
13823 | / ...                   ({
13824 | | ...                        let mut _ret:
13825 | | ...                                u32_0 =
13826 | | ...                            ({
...     |
13902 | | ...                                    libc::c_uint
13903 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
13823 |                                                                                                                         {
13824 |                                                                                                                              let mut _ret:
13825 |                                                                                                                                      u32_0 =
13826 |                                                                                                                                  ({
13827 |                                                                                                                                       let mut _ret_0:
13828 |                                                                                                                                               u32_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:13991:121
      |
13991 | / ...                   ({
13992 | | ...                        let mut _ret:
13993 | | ...                                u32_0 =
13994 | | ...                            ({
...     |
14070 | | ...                                    libc::c_uint
14071 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
13991 |                                                                                                                         {
13992 |                                                                                                                              let mut _ret:
13993 |                                                                                                                                      u32_0 =
13994 |                                                                                                                                  ({
13995 |                                                                                                                                       let mut _ret_0:
13996 |                                                                                                                                               u32_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:14856:113
      |
14856 | / ...                   ({
14857 | | ...                        let mut _ret:
14858 | | ...                                u16_0 =
14859 | | ...                            interesting_16[j
...     |
14880 | | ...                            u16_0
14881 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
14856 |                                                                                                                 {
14857 |                                                                                                                      let mut _ret:
14858 |                                                                                                                              u16_0 =
14859 |                                                                                                                          interesting_16[j
14860 |                                                                                                                                             as
14861 |                                                                                                                                             usize]
    ...

warning: unnecessary parentheses around function argument
     --> src/afl_fuzz_one.rs:15339:139
      |
15339 | / ...                   ({
15340 | | ...                        let mut _ret:
15341 | | ...                                u32_0 =
15342 | | ...                            interesting_32[j
...     |
15381 | | ...                                    libc::c_uint
15382 | | ...                    }),
      | |_________________________^
      |
help: remove these parentheses
      |
15339 |                                                                                                                                           {
15340 |                                                                                                                                                let mut _ret:
15341 |                                                                                                                                                        u32_0 =
15342 |                                                                                                                                                    interesting_32[j
15343 |                                                                                                                                                                       as
15344 |                                                                                                                                                                       usize]
    ...

warning: unnecessary parentheses around function argument
     --> src/afl_fuzz_one.rs:15392:142
      |
15392 | / ...                   ({
15393 | | ...                        let mut _ret:
15394 | | ...                                u32_0 =
15395 | | ...                            interesting_32[j
...     |
15434 | | ...                                    libc::c_uint
15435 | | ...                    }),
      | |_________________________^
      |
help: remove these parentheses
      |
15392 |                                                                                                                                              {
15393 |                                                                                                                                                   let mut _ret:
15394 |                                                                                                                                                           u32_0 =
15395 |                                                                                                                                                       interesting_32[j
15396 |                                                                                                                                                                          as
15397 |                                                                                                                                                                          usize]
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:15462:125
      |
15462 | / ...                   ({
15463 | | ...                        let mut _ret:
15464 | | ...                                u32_0 =
15465 | | ...                            interesting_32[j
...     |
15504 | | ...                                    libc::c_uint
15505 | | ...                    });
      | |_________________________^
      |
help: remove these parentheses
      |
15462 |                                                                                                                             {
15463 |                                                                                                                                  let mut _ret:
15464 |                                                                                                                                          u32_0 =
15465 |                                                                                                                                      interesting_32[j
15466 |                                                                                                                                                         as
15467 |                                                                                                                                                         usize]
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17208:65
      |
17208 | / ...                   ({
17209 | | ...                        let mut _ret:
17210 | | ...                                u16_0 =
17211 | | ...                            (({
...     |
17259 | | ...                            u16_0
17260 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17208 |                                                                 {
17209 |                                                                      let mut _ret:
17210 |                                                                              u16_0 =
17211 |                                                                          (({
17212 |                                                                                let mut _ret_0:
17213 |                                                                                        u16_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17328:65
      |
17328 | / ...                   ({
17329 | | ...                        let mut _ret:
17330 | | ...                                u16_0 =
17331 | | ...                            (({
...     |
17379 | | ...                            u16_0
17380 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17328 |                                                                 {
17329 |                                                                      let mut _ret:
17330 |                                                                              u16_0 =
17331 |                                                                          (({
17332 |                                                                                let mut _ret_0:
17333 |                                                                                        u16_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17468:65
      |
17468 | / ...                   ({
17469 | | ...                        let mut _ret:
17470 | | ...                                u32_0 =
17471 | | ...                            ({
...     |
17548 | | ...                                    libc::c_uint
17549 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17468 |                                                                 {
17469 |                                                                      let mut _ret:
17470 |                                                                              u32_0 =
17471 |                                                                          ({
17472 |                                                                               let mut _ret_0:
17473 |                                                                                       u32_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17617:65
      |
17617 | / ...                   ({
17618 | | ...                        let mut _ret:
17619 | | ...                                u32_0 =
17620 | | ...                            ({
...     |
17697 | | ...                                    libc::c_uint
17698 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17617 |                                                                 {
17618 |                                                                      let mut _ret:
17619 |                                                                              u32_0 =
17620 |                                                                          ({
17621 |                                                                               let mut _ret_0:
17622 |                                                                                       u32_0 =
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17806:65
      |
17806 | / ...                   ({
17807 | | ...                        let mut _ret:
17808 | | ...                                u16_0 =
17809 | | ...                            interesting_16[rand_below(afl,
...     |
17837 | | ...                            u16_0
17838 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17806 |                                                                 {
17807 |                                                                      let mut _ret:
17808 |                                                                              u16_0 =
17809 |                                                                          interesting_16[rand_below(afl,
17810 |                                                                                                    (::std::mem::size_of::<[s16; 19]>()
17811 |                                                                                                         as
    ...

warning: unnecessary parentheses around assigned value
     --> src/afl_fuzz_one.rs:17908:65
      |
17908 | / ...                   ({
17909 | | ...                        let mut _ret:
17910 | | ...                                u32_0 =
17911 | | ...                            interesting_32[rand_below(afl,
...     |
17958 | | ...                                    libc::c_uint
17959 | | ...                    })
      | |_________________________^
      |
help: remove these parentheses
      |
17908 |                                                                 {
17909 |                                                                      let mut _ret:
17910 |                                                                              u32_0 =
17911 |                                                                          interesting_32[rand_below(afl,
17912 |                                                                                                    (::std::mem::size_of::<[s32; 27]>()
17913 |                                                                                                         as
    ...

warning: unnecessary parentheses around function argument
     --> src/afl_fuzz_one.rs:18707:58
      |
18707 | / ...                   ({
18708 | | ...                        let mut _a:
18709 | | ...                                s32 =
18710 | | ...                            len;
...     |
18719 | | ...                        } else { _b }
18720 | | ...                    }), &mut f_diff,
      | |_________________________^
      |
help: remove these parentheses
      |
18707 |                                                          {
18708 |                                                               let mut _a:
18709 |                                                                       s32 =
18710 |                                                                   len;
18711 |                                                               let mut _b:
18712 |                                                                       u32_0 =
    ...

warning: unused import: `::libc`
 --> src/afl_fuzz_python.rs:1:5
  |
1 | use ::libc;
  |     ^^^^^^

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_queue.rs:1771:58
     |
1771 |                            libc::c_ulonglong).wrapping_div((if fuzz ==
     |  __________________________________________________________^
1772 | |                                                                  0 as
1773 | |                                                                      libc::c_int
1774 | |                                                                      as
...    |
1779 | |                                                                   libc::c_ulonglong
1780 | |                                                           } else { fuzz })) as
     | |__________________________________________________________________________^
     |
help: remove these parentheses
     |
1771 |                          libc::c_ulonglong).wrapping_div(if fuzz ==
1772 |                                                                  0 as
1773 |                                                                      libc::c_int
1774 |                                                                      as
1775 |                                                                      libc::c_ulonglong
1776 |                                                              {
   ...

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_queue.rs:1785:54
     |
1785 |                            libc::c_ulong).wrapping_div((if fuzz ==
     |  ______________________________________________________^
1786 | |                                                              0 as libc::c_int
1787 | |                                                                  as
1788 | |                                                                  libc::c_ulonglong
...    |
1794 | |                                                                         size_t)
1795 | |                                                       })) as u32_0
     | |________________________________________________________^
     |
help: remove these parentheses
     |
1785 |                          libc::c_ulong).wrapping_div(if fuzz ==
1786 |                                                              0 as libc::c_int
1787 |                                                                  as
1788 |                                                                  libc::c_ulonglong
1789 |                                                          {
1790 |                                                           1 as libc::c_int as
   ...

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_queue.rs:1801:54
     |
1801 |                        libc::c_ulonglong).wrapping_div((if fuzz ==
     |  ______________________________________________________^
1802 | |                                                              0 as libc::c_int
1803 | |                                                                  as
1804 | |                                                                  libc::c_ulonglong
...    |
1807 | |                                                               libc::c_ulonglong
1808 | |                                                       } else { fuzz })) as
     | |______________________________________________________________________^
     |
help: remove these parentheses
     |
1801 |                      libc::c_ulonglong).wrapping_div(if fuzz ==
1802 |                                                              0 as libc::c_int
1803 |                                                                  as
1804 |                                                                  libc::c_ulonglong
1805 |                                                          {
1806 |                                                           1 as libc::c_int as
   ...

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_queue.rs:1814:54
     |
1814 |                        libc::c_ulonglong).wrapping_div((if fuzz ==
     |  ______________________________________________________^
1815 | |                                                              0 as libc::c_int
1816 | |                                                                  as
1817 | |                                                                  libc::c_ulonglong
...    |
1820 | |                                                               libc::c_ulonglong
1821 | |                                                       } else { fuzz })) as
     | |______________________________________________________________________^
     |
help: remove these parentheses
     |
1814 |                      libc::c_ulonglong).wrapping_div(if fuzz ==
1815 |                                                              0 as libc::c_int
1816 |                                                                  as
1817 |                                                                  libc::c_ulonglong
1818 |                                                          {
1819 |                                                           1 as libc::c_int as
   ...

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_redqueen.rs:1260:36
     |
1260 | / ...                   ({
1261 | | ...                        let mut _ret: u64_0 = pattern;
1262 | | ...                        _ret =
1263 | | ...                            (_ret &
...    |
1294 | | ...                        _ret
1295 | | ...                    }),
     | |_________________________^
     |
help: remove these parentheses
     |
1260 |                                    {
1261 |                                         let mut _ret: u64_0 = pattern;
1262 |                                         _ret =
1263 |                                             (_ret &
1264 |                                                  0xffffffff as libc::c_uint as
1265 |                                                      libc::c_ulonglong) <<
   ...

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_redqueen.rs:1296:36
     |
1296 | / ...                   ({
1297 | | ...                        let mut _ret: u64_0 = repl;
1298 | | ...                        _ret =
1299 | | ...                            (_ret &
...    |
1330 | | ...                        _ret
1331 | | ...                    }), idx, orig_buf, buf, len,
     | |_________________________^
     |
help: remove these parentheses
     |
1296 |                                    {
1297 |                                         let mut _ret: u64_0 = repl;
1298 |                                         _ret =
1299 |                                             (_ret &
1300 |                                                  0xffffffff as libc::c_uint as
1301 |                                                      libc::c_ulonglong) <<
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_redqueen.rs:1478:17
     |
1478 | /                 ({
1479 | |                      let mut _ret: u64_0 = v;
1480 | |                      _ret =
1481 | |                          (_ret &
...    |
1501 | |                      _ret
1502 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
1478 |                 {
1479 |                      let mut _ret: u64_0 = v;
1480 |                      _ret =
1481 |                          (_ret &
1482 |                               0xffffffff as libc::c_uint as libc::c_ulonglong)
1483 |                              << 32 as libc::c_int |
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_redqueen.rs:1602:9
     |
1602 | /         ({
1603 | |              let mut _a: libc::c_int = 32 as libc::c_int;
1604 | |              let mut _b: libc::c_uint = len.wrapping_sub(idx);
1605 | |              if (_a as libc::c_uint) < _b { _a as libc::c_uint } else { _b }
1606 | |          });
     | |___________^
     |
help: remove these parentheses
     |
1602 |         {
1603 |              let mut _a: libc::c_int = 32 as libc::c_int;
1604 |              let mut _b: libc::c_uint = len.wrapping_sub(idx);
1605 |              if (_a as libc::c_uint) < _b { _a as libc::c_uint } else { _b }
1606 |          };
     |

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_redqueen.rs:1760:53
     |
1760 |                            libc::c_uint).wrapping_add(({
     |  _____________________________________________________^
1761 | |                                                          let mut _a: u32_0 =
1762 | |                                                              (*(*afl).shm.cmp_map).headers[k
1763 | |                                                                                                as
...    |
1777 | |                                                          }
1778 | |                                                      })) as s32 as s32
     | |_______________________________________________________^
     |
help: remove these parentheses
     |
1760 |                          libc::c_uint).wrapping_add({
1761 |                                                          let mut _a: u32_0 =
1762 |                                                              (*(*afl).shm.cmp_map).headers[k
1763 |                                                                                                as
1764 |                                                                                                usize].hits();
1765 |                                                          let mut _b:
   ...

warning: unnecessary parentheses around method argument
    --> src/afl_fuzz_redqueen.rs:1782:53
     |
1782 |                            libc::c_uint).wrapping_add(({
     |  _____________________________________________________^
1783 | |                                                          let mut _a: u32_0 =
1784 | |                                                              (*(*afl).shm.cmp_map).headers[k
1785 | |                                                                                                as
...    |
1801 | |                                                          }
1802 | |                                                      })) as s32 as s32
     | |_______________________________________________________^
     |
help: remove these parentheses
     |
1782 |                          libc::c_uint).wrapping_add({
1783 |                                                          let mut _a: u32_0 =
1784 |                                                              (*(*afl).shm.cmp_map).headers[k
1785 |                                                                                                as
1786 |                                                                                                usize].hits();
1787 |                                                          let mut _b:
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:1518:13
     |
1518 | /             ({
1519 | |                  let mut _a: libc::c_uint =
1520 | |                      (*afl).fsrv.exec_tmout.wrapping_add(50 as libc::c_int as
1521 | |                                                              libc::c_uint);
...    |
1529 | |                  if _a > _b { _a } else { _b }
1530 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
1518 |             {
1519 |                  let mut _a: libc::c_uint =
1520 |                      (*afl).fsrv.exec_tmout.wrapping_add(50 as libc::c_int as
1521 |                                                              libc::c_uint);
1522 |                  let mut _b: libc::c_uint =
1523 |                      (*afl).fsrv.exec_tmout.wrapping_mul(125 as libc::c_int as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:1734:13
     |
1734 | /             ({
1735 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1736 | |                  let mut _len: s32 =
1737 | |                      snprintf(0 as *mut libc::c_char,
...    |
1761 | |                  _tmp
1762 | |              });
     | |_______________^
     |
help: remove these parentheses
     |
1734 |             {
1735 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1736 |                  let mut _len: s32 =
1737 |                      snprintf(0 as *mut libc::c_char,
1738 |                               0 as libc::c_int as libc::c_ulong,
1739 |                               b"%s/%s/queue\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:1769:17
     |
1769 | /                 ({
1770 | |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1771 | |                      let mut _len: s32 =
1772 | |                          snprintf(0 as *mut libc::c_char,
...    |
1796 | |                      _tmp
1797 | |                  });
     | |___________________^
     |
help: remove these parentheses
     |
1769 |                 {
1770 |                      let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1771 |                      let mut _len: s32 =
1772 |                          snprintf(0 as *mut libc::c_char,
1773 |                                   0 as libc::c_int as libc::c_ulong,
1774 |                                   b"%s/.synced/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:1877:21
     |
1877 | /                     ({
1878 | |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1879 | |                          let mut _len: s32 =
1880 | |                              snprintf(0 as *mut libc::c_char,
...    |
1905 | |                          _tmp
1906 | |                      });
     | |_______________________^
     |
help: remove these parentheses
     |
1877 |                     {
1878 |                          let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
1879 |                          let mut _len: s32 =
1880 |                              snprintf(0 as *mut libc::c_char,
1881 |                                       0 as libc::c_int as libc::c_ulong,
1882 |                                       b"%s/%s\x00" as *const u8 as
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:2081:9
     |
2081 | /         ({
2082 | |              let mut _a: libc::c_uint =
2083 | |                  len_p2.wrapping_div(16 as libc::c_int as libc::c_uint);
2084 | |              let mut _b: libc::c_int = 4 as libc::c_int;
2085 | |              if _a > _b as libc::c_uint { _a } else { _b as libc::c_uint }
2086 | |          });
     | |___________^
     |
help: remove these parentheses
     |
2081 |         {
2082 |              let mut _a: libc::c_uint =
2083 |                  len_p2.wrapping_div(16 as libc::c_int as libc::c_uint);
2084 |              let mut _b: libc::c_int = 4 as libc::c_int;
2085 |              if _a > _b as libc::c_uint { _a } else { _b as libc::c_uint }
2086 |          };
     |

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_run.rs:2118:21
     |
2118 | /                     ({
2119 | |                          let mut _a: u32_0 = remove_len;
2120 | |                          let mut _b: libc::c_uint =
2121 | |                              (*q).len.wrapping_sub(remove_pos);
2122 | |                          if _a < _b { _a } else { _b }
2123 | |                      });
     | |_______________________^
     |
help: remove these parentheses
     |
2118 |                     {
2119 |                          let mut _a: u32_0 = remove_len;
2120 |                          let mut _b: libc::c_uint =
2121 |                              (*q).len.wrapping_sub(remove_pos);
2122 |                          if _a < _b { _a } else { _b }
2123 |                      };
     |

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_stats.rs:1840:20
     |
1840 | /                    ({
1841 | |                         let mut _a: s32 = (*afl).cpu_aff;
1842 | |                         let mut _b: libc::c_int = 999 as libc::c_int;
1843 | |                         if _a < _b { _a } else { _b }
1844 | |                     }), cpu_color,
     | |______________________^
     |
help: remove these parentheses
     |
1840 |                    {
1841 |                         let mut _a: s32 = (*afl).cpu_aff;
1842 |                         let mut _b: libc::c_int = 999 as libc::c_int;
1843 |                         if _a < _b { _a } else { _b }
1844 |                     }, cpu_color,
     |

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_stats.rs:1845:20
     |
1845 | /                    ({
1846 | |                         let mut _a: u32_0 = cur_utilization;
1847 | |                         let mut _b: libc::c_int = 999 as libc::c_int;
1848 | |                         if _a < _b as libc::c_uint {
1849 | |                             _a
1850 | |                         } else { _b as libc::c_uint }
1851 | |                     }));
     | |______________________^
     |
help: remove these parentheses
     |
1845 |                    {
1846 |                         let mut _a: u32_0 = cur_utilization;
1847 |                         let mut _b: libc::c_int = 999 as libc::c_int;
1848 |                         if _a < _b as libc::c_uint {
1849 |                             _a
1850 |                         } else { _b as libc::c_uint }
   ...

warning: unnecessary parentheses around function argument
    --> src/afl_fuzz_stats.rs:1855:20
     |
1855 | /                    ({
1856 | |                         let mut _a: u32_0 = cur_utilization;
1857 | |                         let mut _b: libc::c_int = 999 as libc::c_int;
1858 | |                         if _a < _b as libc::c_uint {
1859 | |                             _a
1860 | |                         } else { _b as libc::c_uint }
1861 | |                     }));
     | |______________________^
     |
help: remove these parentheses
     |
1855 |                    {
1856 |                         let mut _a: u32_0 = cur_utilization;
1857 |                         let mut _b: libc::c_int = 999 as libc::c_int;
1858 |                         if _a < _b as libc::c_uint {
1859 |                             _a
1860 |                         } else { _b as libc::c_uint }
   ...

warning: unnecessary parentheses around assigned value
    --> src/afl_fuzz_stats.rs:2448:13
     |
2448 | /             ({
2449 | |                  let mut _a: libc::c_int = 1000 as libc::c_int;
2450 | |                  let mut _b: libc::c_uint =
2451 | |                      (*afl).fsrv.exec_tmout.wrapping_mul(2 as libc::c_int as
...    |
2459 | |                  } else { _b }
2460 | |              })
     | |_______________^
     |
help: remove these parentheses
     |
2448 |             {
2449 |                  let mut _a: libc::c_int = 1000 as libc::c_int;
2450 |                  let mut _b: libc::c_uint =
2451 |                      (*afl).fsrv.exec_tmout.wrapping_mul(2 as libc::c_int as
2452 |                                                              libc::c_uint).wrapping_add(100
2453 |                                                                                             as
   ...

warning: unnecessary parentheses around assigned value
   --> src/afl_gcc.rs:189:13
    |
189 | /             ({
190 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
191 | |                  let mut _len: s32 =
192 | |                      snprintf(0 as *mut libc::c_char,
...   |
214 | |                  _tmp
215 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
189 |             {
190 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
191 |                  let mut _len: s32 =
192 |                      snprintf(0 as *mut libc::c_char,
193 |                               0 as libc::c_int as libc::c_ulong,
194 |                               b"%s/as\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_gcc.rs:230:13
    |
230 | /             ({
231 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
232 | |                  let mut _len: s32 =
233 | |                      snprintf(0 as *mut libc::c_char,
...   |
255 | |                  _tmp
256 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
230 |             {
231 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
232 |                  let mut _len: s32 =
233 |                      snprintf(0 as *mut libc::c_char,
234 |                               0 as libc::c_int as libc::c_ulong,
235 |                               b"%s/afl-as\x00" as *const u8 as
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_sharedmem.rs:621:9
    |
621 | /         ({
622 | |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
623 | |              let mut _len: s32 =
624 | |                  snprintf(0 as *mut libc::c_char,
...   |
646 | |              _tmp
647 | |          });
    | |___________^
    |
help: remove these parentheses
    |
621 |         {
622 |              let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
623 |              let mut _len: s32 =
624 |                  snprintf(0 as *mut libc::c_char,
625 |                           0 as libc::c_int as libc::c_ulong,
626 |                           b"%d\x00" as *const u8 as *const libc::c_char,
  ...

warning: unnecessary parentheses around assigned value
   --> src/afl_sharedmem.rs:659:13
    |
659 | /             ({
660 | |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
661 | |                  let mut _len: s32 =
662 | |                      snprintf(0 as *mut libc::c_char,
...   |
684 | |                  _tmp
685 | |              });
    | |_______________^
    |
help: remove these parentheses
    |
659 |             {
660 |                  let mut _tmp: *mut u8_0 = 0 as *mut u8_0;
661 |                  let mut _len: s32 =
662 |                      snprintf(0 as *mut libc::c_char,
663 |                               0 as libc::c_int as libc::c_ulong,
664 |                               b"%d\x00" as *const u8 as *const libc::c_char,
  ...

error[E0658]: unions with non-`Copy` fields are unstable
   --> src/afl_fuzz_init.rs:659:1
    |
659 | / pub union C2RustUnnamed_0 {
660 | |     pub _pad: [libc::c_int; 28],
661 | |     pub _kill: C2RustUnnamed_9,
662 | |     pub _timer: C2RustUnnamed_8,
...   |
667 | |     pub _sigsys: C2RustUnnamed_1,
668 | | }
    | |_^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/55149

error[E0658]: unions with non-`Copy` fields are unstable
   --> src/afl_fuzz_init.rs:691:1
    |
691 | / pub union C2RustUnnamed_4 {
692 | |     pub _addr_bnd: C2RustUnnamed_5,
693 | |     pub _pkey: __uint32_t,
694 | | }
    | |_^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/55149

error: aborting due to 422 previous errors

Some errors have detailed explanations: E0554, E0658.
For more information about an error, try `rustc --explain E0554`.
error: could not compile `c2rust_out`.

To learn more, run the command again with --verbose.

[domenukk]

Can you try the following from the c2rust docs (https://github.com/immunant/c2rust)

rustup install nightly-2019-12-05
rustup component add --toolchain nightly-2019-12-05 rustfmt rustc-dev