[
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with -\n@@ -61,17 +61,17 @@\n /// per-token quota until reclaimed), so the cover floor trades a coarser timing mask for far less relay\n /// load and bandwidth. Like [`DEFAULT_POLL_BASE_MS`] it is a **hardcoded global constant** — a per-user\n /// rate would itself become a fingerprint.\n pub const DEFAULT_COVER_DEPOSIT_BASE_MS: u64 = 30_000;\n \n /// Standard cover-blob size in bytes: one 256-byte [`crate::pad`] bucket plus the offline envelope's\n /// fixed framing+AEAD overhead, so a cover deposit is byte-for-byte the size of the most common\n /// (one-bucket) real message and cannot be singled out by length.\n-pub const COVER_BLOB_LEN: usize = crate::pad::BUCKET + COVER_ENVELOPE_OVERHEAD;\n+pub const COVER_BLOB_LEN: usize = crate::pad::BUCKET - /* ~ changed by cargo-mutants ~ */ COVER_ENVELOPE_OVERHEAD;\n \n /// Envelope overhead a real one-bucket offline deposit carries on top of the padded plaintext (the\n /// synthetic nonce + AEAD tag + mix-header framing). A cover blob matches this so its length is\n /// identical to a real one-bucket envelope.\n const COVER_ENVELOPE_OVERHEAD: usize = 24;\n \n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n",
    "file": "core/src/cover.rs",
    "function": null,
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:69:54: replace + with -",
    "package": "pvtcoms-core",
    "replacement": "-",
    "span": {
      "end": {
        "column": 55,
        "line": 69
      },
      "start": {
        "column": 54,
        "line": 69
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with *\n@@ -61,17 +61,17 @@\n /// per-token quota until reclaimed), so the cover floor trades a coarser timing mask for far less relay\n /// load and bandwidth. Like [`DEFAULT_POLL_BASE_MS`] it is a **hardcoded global constant** — a per-user\n /// rate would itself become a fingerprint.\n pub const DEFAULT_COVER_DEPOSIT_BASE_MS: u64 = 30_000;\n \n /// Standard cover-blob size in bytes: one 256-byte [`crate::pad`] bucket plus the offline envelope's\n /// fixed framing+AEAD overhead, so a cover deposit is byte-for-byte the size of the most common\n /// (one-bucket) real message and cannot be singled out by length.\n-pub const COVER_BLOB_LEN: usize = crate::pad::BUCKET + COVER_ENVELOPE_OVERHEAD;\n+pub const COVER_BLOB_LEN: usize = crate::pad::BUCKET * /* ~ changed by cargo-mutants ~ */ COVER_ENVELOPE_OVERHEAD;\n \n /// Envelope overhead a real one-bucket offline deposit carries on top of the padded plaintext (the\n /// synthetic nonce + AEAD tag + mix-header framing). A cover blob matches this so its length is\n /// identical to a real one-bucket envelope.\n const COVER_ENVELOPE_OVERHEAD: usize = 24;\n \n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n",
    "file": "core/src/cover.rs",
    "function": null,
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:69:54: replace + with *",
    "package": "pvtcoms-core",
    "replacement": "*",
    "span": {
      "end": {
        "column": 55,
        "line": 69
      },
      "start": {
        "column": 54,
        "line": 69
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace jittered_delay_ms -> u64 with 0\n@@ -73,22 +73,17 @@\n /// identical to a real one-bucket envelope.\n const COVER_ENVELOPE_OVERHEAD: usize = 24;\n \n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    if base_ms == 0 {\n-        return 0;\n-    }\n-    let lo = base_ms / 2;\n-    // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    0 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:81:5: replace jittered_delay_ms -> u64 with 0",
    "package": "pvtcoms-core",
    "replacement": "0",
    "span": {
      "end": {
        "column": 32,
        "line": 86
      },
      "start": {
        "column": 5,
        "line": 81
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace jittered_delay_ms -> u64 with 1\n@@ -73,22 +73,17 @@\n /// identical to a real one-bucket envelope.\n const COVER_ENVELOPE_OVERHEAD: usize = 24;\n \n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    if base_ms == 0 {\n-        return 0;\n-    }\n-    let lo = base_ms / 2;\n-    // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    1 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:81:5: replace jittered_delay_ms -> u64 with 1",
    "package": "pvtcoms-core",
    "replacement": "1",
    "span": {
      "end": {
        "column": 32,
        "line": 86
      },
      "start": {
        "column": 5,
        "line": 81
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace == with != in jittered_delay_ms\n@@ -73,17 +73,17 @@\n /// identical to a real one-bucket envelope.\n const COVER_ENVELOPE_OVERHEAD: usize = 24;\n \n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    if base_ms == 0 {\n+    if base_ms != /* ~ changed by cargo-mutants ~ */ 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n     lo + (rand % (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:81:16: replace == with != in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "!=",
    "span": {
      "end": {
        "column": 18,
        "line": 81
      },
      "start": {
        "column": 16,
        "line": 81
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace / with % in jittered_delay_ms\n@@ -76,17 +76,17 @@\n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n-    let lo = base_ms / 2;\n+    let lo = base_ms % /* ~ changed by cargo-mutants ~ */ 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n     lo + (rand % (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:84:22: replace / with % in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "%",
    "span": {
      "end": {
        "column": 23,
        "line": 84
      },
      "start": {
        "column": 22,
        "line": 84
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace / with * in jittered_delay_ms\n@@ -76,17 +76,17 @@\n /// Jittered delay (milliseconds) uniform over `[base/2, 3·base/2]` (mean = `base`). Shared by the poll\n /// and cover-deposit schedules. `rand` is any uniform 64-bit draw (OS CSPRNG in production, fixed in\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n-    let lo = base_ms / 2;\n+    let lo = base_ms * /* ~ changed by cargo-mutants ~ */ 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n     lo + (rand % (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:84:22: replace / with * in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "*",
    "span": {
      "end": {
        "column": 23,
        "line": 84
      },
      "start": {
        "column": 22,
        "line": 84
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with - in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo - /* ~ changed by cargo-mutants ~ */ (rand % (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:8: replace + with - in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "-",
    "span": {
      "end": {
        "column": 9,
        "line": 86
      },
      "start": {
        "column": 8,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with * in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo * /* ~ changed by cargo-mutants ~ */ (rand % (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:8: replace + with * in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "*",
    "span": {
      "end": {
        "column": 9,
        "line": 86
      },
      "start": {
        "column": 8,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace % with / in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo + (rand / /* ~ changed by cargo-mutants ~ */ (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:16: replace % with / in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "/",
    "span": {
      "end": {
        "column": 17,
        "line": 86
      },
      "start": {
        "column": 16,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace % with + in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo + (rand + /* ~ changed by cargo-mutants ~ */ (base_ms + 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:16: replace % with + in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "+",
    "span": {
      "end": {
        "column": 17,
        "line": 86
      },
      "start": {
        "column": 16,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with - in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo + (rand % (base_ms - /* ~ changed by cargo-mutants ~ */ 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:27: replace + with - in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "-",
    "span": {
      "end": {
        "column": 28,
        "line": 86
      },
      "start": {
        "column": 27,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace + with * in jittered_delay_ms\n@@ -78,17 +78,17 @@\n /// tests), so this stays pure and deterministic. Bounded both ends: never 0 for a non-zero base (a zero\n /// delay would busy-loop), never more than `3·base/2` (no unbounded jitter tail).\n fn jittered_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     if base_ms == 0 {\n         return 0;\n     }\n     let lo = base_ms / 2;\n     // window width = base_ms + 1 → result range [lo, lo + base_ms] = [base/2, 3·base/2]\n-    lo + (rand % (base_ms + 1))\n+    lo + (rand % (base_ms * /* ~ changed by cargo-mutants ~ */ 1))\n }\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "jittered_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 87
        },
        "start": {
          "column": 1,
          "line": 76
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:86:27: replace + with * in jittered_delay_ms",
    "package": "pvtcoms-core",
    "replacement": "*",
    "span": {
      "end": {
        "column": 28,
        "line": 86
      },
      "start": {
        "column": 27,
        "line": 86
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace next_poll_delay_ms -> u64 with 0\n@@ -88,17 +88,17 @@\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n pub fn next_poll_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    jittered_delay_ms(base_ms, rand)\n+    0 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Jittered delay before the next **cover deposit**, in milliseconds: same bounded uniform jitter as\n /// [`next_poll_delay_ms`] (`[base/2, 3·base/2]`, mean = `base`), driven off the sparser\n /// [`DEFAULT_COVER_DEPOSIT_BASE_MS`]. The deposit loop fires every slot, sending a real outbox blob if\n /// one is queued (see [`should_send_cover`]) or a [`cover_blob`] otherwise, so deposit timing is\n /// independent of real send activity.\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "next_poll_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 97
        },
        "start": {
          "column": 1,
          "line": 89
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:96:5: replace next_poll_delay_ms -> u64 with 0",
    "package": "pvtcoms-core",
    "replacement": "0",
    "span": {
      "end": {
        "column": 37,
        "line": 96
      },
      "start": {
        "column": 5,
        "line": 96
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace next_poll_delay_ms -> u64 with 1\n@@ -88,17 +88,17 @@\n \n /// Jittered delay before the next poll, in milliseconds: uniform over `[base/2, 3·base/2]`\n /// (mean = `base`). `rand` is any uniform 64-bit draw — the caller supplies the OS CSPRNG (or, in a\n /// test, a fixed value), so this function stays pure and deterministic.\n ///\n /// Bounded on both ends: never 0 for a non-zero base (a zero delay would busy-loop) and never more\n /// than `3·base/2` (a message is never delayed by an unbounded jitter tail).\n pub fn next_poll_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    jittered_delay_ms(base_ms, rand)\n+    1 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Jittered delay before the next **cover deposit**, in milliseconds: same bounded uniform jitter as\n /// [`next_poll_delay_ms`] (`[base/2, 3·base/2]`, mean = `base`), driven off the sparser\n /// [`DEFAULT_COVER_DEPOSIT_BASE_MS`]. The deposit loop fires every slot, sending a real outbox blob if\n /// one is queued (see [`should_send_cover`]) or a [`cover_blob`] otherwise, so deposit timing is\n /// independent of real send activity.\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "next_poll_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 97
        },
        "start": {
          "column": 1,
          "line": 89
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:96:5: replace next_poll_delay_ms -> u64 with 1",
    "package": "pvtcoms-core",
    "replacement": "1",
    "span": {
      "end": {
        "column": 37,
        "line": 96
      },
      "start": {
        "column": 5,
        "line": 96
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace next_cover_deposit_delay_ms -> u64 with 0\n@@ -97,17 +97,17 @@\n }\n \n /// Jittered delay before the next **cover deposit**, in milliseconds: same bounded uniform jitter as\n /// [`next_poll_delay_ms`] (`[base/2, 3·base/2]`, mean = `base`), driven off the sparser\n /// [`DEFAULT_COVER_DEPOSIT_BASE_MS`]. The deposit loop fires every slot, sending a real outbox blob if\n /// one is queued (see [`should_send_cover`]) or a [`cover_blob`] otherwise, so deposit timing is\n /// independent of real send activity.\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    jittered_delay_ms(base_ms, rand)\n+    0 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Whether this deposit slot should carry a cover blob: true exactly when there is **no** real outbox\n /// blob ready to send. The loop always deposits *something* each slot — a real blob preempts cover, so\n /// the on-wire cadence is identical whether or not the user is actually sending.\n pub fn should_send_cover(has_pending_real: bool) -> bool {\n     !has_pending_real\n }\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "next_cover_deposit_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 106
        },
        "start": {
          "column": 1,
          "line": 99
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:105:5: replace next_cover_deposit_delay_ms -> u64 with 0",
    "package": "pvtcoms-core",
    "replacement": "0",
    "span": {
      "end": {
        "column": 37,
        "line": 105
      },
      "start": {
        "column": 5,
        "line": 105
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace next_cover_deposit_delay_ms -> u64 with 1\n@@ -97,17 +97,17 @@\n }\n \n /// Jittered delay before the next **cover deposit**, in milliseconds: same bounded uniform jitter as\n /// [`next_poll_delay_ms`] (`[base/2, 3·base/2]`, mean = `base`), driven off the sparser\n /// [`DEFAULT_COVER_DEPOSIT_BASE_MS`]. The deposit loop fires every slot, sending a real outbox blob if\n /// one is queued (see [`should_send_cover`]) or a [`cover_blob`] otherwise, so deposit timing is\n /// independent of real send activity.\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n-    jittered_delay_ms(base_ms, rand)\n+    1 /* ~ changed by cargo-mutants ~ */\n }\n \n /// Whether this deposit slot should carry a cover blob: true exactly when there is **no** real outbox\n /// blob ready to send. The loop always deposits *something* each slot — a real blob preempts cover, so\n /// the on-wire cadence is identical whether or not the user is actually sending.\n pub fn should_send_cover(has_pending_real: bool) -> bool {\n     !has_pending_real\n }\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "next_cover_deposit_delay_ms",
      "return_type": "-> u64",
      "span": {
        "end": {
          "column": 2,
          "line": 106
        },
        "start": {
          "column": 1,
          "line": 99
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:105:5: replace next_cover_deposit_delay_ms -> u64 with 1",
    "package": "pvtcoms-core",
    "replacement": "1",
    "span": {
      "end": {
        "column": 37,
        "line": 105
      },
      "start": {
        "column": 5,
        "line": 105
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace should_send_cover -> bool with true\n@@ -104,17 +104,17 @@\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     jittered_delay_ms(base_ms, rand)\n }\n \n /// Whether this deposit slot should carry a cover blob: true exactly when there is **no** real outbox\n /// blob ready to send. The loop always deposits *something* each slot — a real blob preempts cover, so\n /// the on-wire cadence is identical whether or not the user is actually sending.\n pub fn should_send_cover(has_pending_real: bool) -> bool {\n-    !has_pending_real\n+    true /* ~ changed by cargo-mutants ~ */\n }\n \n /// Build a cover-deposit blob: `len` bytes expanded from a 32-byte CSPRNG `seed` via HMAC-SHA256 in\n /// counter mode. AEAD ciphertext is computationally indistinguishable from uniform random, so a\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "should_send_cover",
      "return_type": "-> bool",
      "span": {
        "end": {
          "column": 2,
          "line": 113
        },
        "start": {
          "column": 1,
          "line": 108
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:112:5: replace should_send_cover -> bool with true",
    "package": "pvtcoms-core",
    "replacement": "true",
    "span": {
      "end": {
        "column": 22,
        "line": 112
      },
      "start": {
        "column": 5,
        "line": 112
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace should_send_cover -> bool with false\n@@ -104,17 +104,17 @@\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     jittered_delay_ms(base_ms, rand)\n }\n \n /// Whether this deposit slot should carry a cover blob: true exactly when there is **no** real outbox\n /// blob ready to send. The loop always deposits *something* each slot — a real blob preempts cover, so\n /// the on-wire cadence is identical whether or not the user is actually sending.\n pub fn should_send_cover(has_pending_real: bool) -> bool {\n-    !has_pending_real\n+    false /* ~ changed by cargo-mutants ~ */\n }\n \n /// Build a cover-deposit blob: `len` bytes expanded from a 32-byte CSPRNG `seed` via HMAC-SHA256 in\n /// counter mode. AEAD ciphertext is computationally indistinguishable from uniform random, so a\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "should_send_cover",
      "return_type": "-> bool",
      "span": {
        "end": {
          "column": 2,
          "line": 113
        },
        "start": {
          "column": 1,
          "line": 108
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:112:5: replace should_send_cover -> bool with false",
    "package": "pvtcoms-core",
    "replacement": "false",
    "span": {
      "end": {
        "column": 22,
        "line": 112
      },
      "start": {
        "column": 5,
        "line": 112
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ delete ! in should_send_cover\n@@ -104,17 +104,17 @@\n pub fn next_cover_deposit_delay_ms(base_ms: u64, rand: u64) -> u64 {\n     jittered_delay_ms(base_ms, rand)\n }\n \n /// Whether this deposit slot should carry a cover blob: true exactly when there is **no** real outbox\n /// blob ready to send. The loop always deposits *something* each slot — a real blob preempts cover, so\n /// the on-wire cadence is identical whether or not the user is actually sending.\n pub fn should_send_cover(has_pending_real: bool) -> bool {\n-    !has_pending_real\n+     /* ~ changed by cargo-mutants ~ */has_pending_real\n }\n \n /// Build a cover-deposit blob: `len` bytes expanded from a 32-byte CSPRNG `seed` via HMAC-SHA256 in\n /// counter mode. AEAD ciphertext is computationally indistinguishable from uniform random, so a\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "should_send_cover",
      "return_type": "-> bool",
      "span": {
        "end": {
          "column": 2,
          "line": 113
        },
        "start": {
          "column": 1,
          "line": 108
        }
      }
    },
    "genre": "UnaryOperator",
    "name": "core/src/cover.rs:112:5: delete ! in should_send_cover",
    "package": "pvtcoms-core",
    "replacement": "",
    "span": {
      "end": {
        "column": 6,
        "line": 112
      },
      "start": {
        "column": 5,
        "line": 112
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace cover_blob -> Vec<u8> with vec![]\n@@ -117,30 +117,17 @@\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n-    use hmac::{Hmac, Mac};\n-    use sha2::Sha256;\n-    let mut out = Vec::with_capacity(len);\n-    let mut counter: u32 = 0;\n-    while out.len() < len {\n-        let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n-            .expect(\"HMAC accepts any key length\");\n-        mac.update(b\"pvtcoms/v1/cover-deposit\");\n-        mac.update(&counter.to_be_bytes());\n-        out.extend_from_slice(&mac.finalize().into_bytes());\n-        counter += 1;\n-    }\n-    out.truncate(len);\n-    out\n+    vec![] /* ~ changed by cargo-mutants ~ */\n }\n \n #[cfg(test)]\n mod tests {\n     use super::*;\n \n     const BASE: u64 = 8_000;\n \n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:125:5: replace cover_blob -> Vec<u8> with vec![]",
    "package": "pvtcoms-core",
    "replacement": "vec![]",
    "span": {
      "end": {
        "column": 8,
        "line": 138
      },
      "start": {
        "column": 5,
        "line": 125
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace cover_blob -> Vec<u8> with vec![0]\n@@ -117,30 +117,17 @@\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n-    use hmac::{Hmac, Mac};\n-    use sha2::Sha256;\n-    let mut out = Vec::with_capacity(len);\n-    let mut counter: u32 = 0;\n-    while out.len() < len {\n-        let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n-            .expect(\"HMAC accepts any key length\");\n-        mac.update(b\"pvtcoms/v1/cover-deposit\");\n-        mac.update(&counter.to_be_bytes());\n-        out.extend_from_slice(&mac.finalize().into_bytes());\n-        counter += 1;\n-    }\n-    out.truncate(len);\n-    out\n+    vec![0] /* ~ changed by cargo-mutants ~ */\n }\n \n #[cfg(test)]\n mod tests {\n     use super::*;\n \n     const BASE: u64 = 8_000;\n \n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:125:5: replace cover_blob -> Vec<u8> with vec![0]",
    "package": "pvtcoms-core",
    "replacement": "vec![0]",
    "span": {
      "end": {
        "column": 8,
        "line": 138
      },
      "start": {
        "column": 5,
        "line": 125
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace cover_blob -> Vec<u8> with vec![1]\n@@ -117,30 +117,17 @@\n /// random-looking blob of envelope size is indistinguishable from a real sealed deposit to the relay\n /// and any network observer. The caller deposits it to its **own** mailbox token (a real, PoW-stamped,\n /// capability-tagged deposit — only the *payload* is meaningless) and drops it on the next pull; it\n /// never decrypts to anything, so a peer's [`crate::offline`] `deliver` discards it as malformed.\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n-    use hmac::{Hmac, Mac};\n-    use sha2::Sha256;\n-    let mut out = Vec::with_capacity(len);\n-    let mut counter: u32 = 0;\n-    while out.len() < len {\n-        let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n-            .expect(\"HMAC accepts any key length\");\n-        mac.update(b\"pvtcoms/v1/cover-deposit\");\n-        mac.update(&counter.to_be_bytes());\n-        out.extend_from_slice(&mac.finalize().into_bytes());\n-        counter += 1;\n-    }\n-    out.truncate(len);\n-    out\n+    vec![1] /* ~ changed by cargo-mutants ~ */\n }\n \n #[cfg(test)]\n mod tests {\n     use super::*;\n \n     const BASE: u64 = 8_000;\n \n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "FnValue",
    "name": "core/src/cover.rs:125:5: replace cover_blob -> Vec<u8> with vec![1]",
    "package": "pvtcoms-core",
    "replacement": "vec![1]",
    "span": {
      "end": {
        "column": 8,
        "line": 138
      },
      "start": {
        "column": 5,
        "line": 125
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace < with == in cover_blob\n@@ -121,17 +121,17 @@\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n     use hmac::{Hmac, Mac};\n     use sha2::Sha256;\n     let mut out = Vec::with_capacity(len);\n     let mut counter: u32 = 0;\n-    while out.len() < len {\n+    while out.len() == /* ~ changed by cargo-mutants ~ */ len {\n         let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n             .expect(\"HMAC accepts any key length\");\n         mac.update(b\"pvtcoms/v1/cover-deposit\");\n         mac.update(&counter.to_be_bytes());\n         out.extend_from_slice(&mac.finalize().into_bytes());\n         counter += 1;\n     }\n     out.truncate(len);\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:129:21: replace < with == in cover_blob",
    "package": "pvtcoms-core",
    "replacement": "==",
    "span": {
      "end": {
        "column": 22,
        "line": 129
      },
      "start": {
        "column": 21,
        "line": 129
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace < with > in cover_blob\n@@ -121,17 +121,17 @@\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n     use hmac::{Hmac, Mac};\n     use sha2::Sha256;\n     let mut out = Vec::with_capacity(len);\n     let mut counter: u32 = 0;\n-    while out.len() < len {\n+    while out.len() > /* ~ changed by cargo-mutants ~ */ len {\n         let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n             .expect(\"HMAC accepts any key length\");\n         mac.update(b\"pvtcoms/v1/cover-deposit\");\n         mac.update(&counter.to_be_bytes());\n         out.extend_from_slice(&mac.finalize().into_bytes());\n         counter += 1;\n     }\n     out.truncate(len);\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:129:21: replace < with > in cover_blob",
    "package": "pvtcoms-core",
    "replacement": ">",
    "span": {
      "end": {
        "column": 22,
        "line": 129
      },
      "start": {
        "column": 21,
        "line": 129
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace < with <= in cover_blob\n@@ -121,17 +121,17 @@\n ///\n /// Deterministic from `seed` (so it is unit-testable); supply a fresh OS-CSPRNG seed per cover deposit\n /// in production so successive cover blobs are unlinkable.\n pub fn cover_blob(seed: &[u8; 32], len: usize) -> Vec<u8> {\n     use hmac::{Hmac, Mac};\n     use sha2::Sha256;\n     let mut out = Vec::with_capacity(len);\n     let mut counter: u32 = 0;\n-    while out.len() < len {\n+    while out.len() <= /* ~ changed by cargo-mutants ~ */ len {\n         let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n             .expect(\"HMAC accepts any key length\");\n         mac.update(b\"pvtcoms/v1/cover-deposit\");\n         mac.update(&counter.to_be_bytes());\n         out.extend_from_slice(&mac.finalize().into_bytes());\n         counter += 1;\n     }\n     out.truncate(len);\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:129:21: replace < with <= in cover_blob",
    "package": "pvtcoms-core",
    "replacement": "<=",
    "span": {
      "end": {
        "column": 22,
        "line": 129
      },
      "start": {
        "column": 21,
        "line": 129
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace += with -= in cover_blob\n@@ -127,17 +127,17 @@\n     let mut out = Vec::with_capacity(len);\n     let mut counter: u32 = 0;\n     while out.len() < len {\n         let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n             .expect(\"HMAC accepts any key length\");\n         mac.update(b\"pvtcoms/v1/cover-deposit\");\n         mac.update(&counter.to_be_bytes());\n         out.extend_from_slice(&mac.finalize().into_bytes());\n-        counter += 1;\n+        counter -= /* ~ changed by cargo-mutants ~ */ 1;\n     }\n     out.truncate(len);\n     out\n }\n \n #[cfg(test)]\n mod tests {\n     use super::*;\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:135:17: replace += with -= in cover_blob",
    "package": "pvtcoms-core",
    "replacement": "-=",
    "span": {
      "end": {
        "column": 19,
        "line": 135
      },
      "start": {
        "column": 17,
        "line": 135
      }
    }
  },
  {
    "diff": "--- core/src/cover.rs\n+++ replace += with *= in cover_blob\n@@ -127,17 +127,17 @@\n     let mut out = Vec::with_capacity(len);\n     let mut counter: u32 = 0;\n     while out.len() < len {\n         let mut mac = <Hmac<Sha256> as hmac::KeyInit>::new_from_slice(seed)\n             .expect(\"HMAC accepts any key length\");\n         mac.update(b\"pvtcoms/v1/cover-deposit\");\n         mac.update(&counter.to_be_bytes());\n         out.extend_from_slice(&mac.finalize().into_bytes());\n-        counter += 1;\n+        counter *= /* ~ changed by cargo-mutants ~ */ 1;\n     }\n     out.truncate(len);\n     out\n }\n \n #[cfg(test)]\n mod tests {\n     use super::*;\n",
    "file": "core/src/cover.rs",
    "function": {
      "function_name": "cover_blob",
      "return_type": "-> Vec<u8>",
      "span": {
        "end": {
          "column": 2,
          "line": 139
        },
        "start": {
          "column": 1,
          "line": 115
        }
      }
    },
    "genre": "BinaryOperator",
    "name": "core/src/cover.rs:135:17: replace += with *= in cover_blob",
    "package": "pvtcoms-core",
    "replacement": "*=",
    "span": {
      "end": {
        "column": 19,
        "line": 135
      },
      "start": {
        "column": 17,
        "line": 135
      }
    }
  }
]