         CheckResults(isDisjoint == r)
     }
 }
+
+@inline(never)
+func run_SetIsDisjointSeqBox(
+    _ a: Set<Box<Int>>,
+    _ b: Array<Box<Int>>,
+    _ r: Bool,
+    _ n: Int) {
+    for _ in 0 ..< n {
+        let isDisjoint = a.isDisjoint(with: identity(b))
+        CheckResults(isDisjoint == r)
+    }
+}

    }
}

class Box<T : Hashable> : Hashable {
  var value: T


    setUpFunction: { blackHole([setY, setXY]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Int100",
    runFunction: { n in run_SetIsStrictSubsetInt(setP, setQ, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setP, setQ]) }),

  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Empty.Int",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setE, arrayAB, true, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setE, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Int.Empty",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setAB, arrayE, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayE]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Int0",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setAB, arrayCD, false, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayCD]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Box0",
    runFunction: { n in run_SetIsStrictSubsetSeqBox(setOAB, arrayOCD, false, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOAB, arrayOCD]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Int25",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setB, arrayAB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setB, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Box25",
    runFunction: { n in run_SetIsStrictSubsetSeqBox(setOB, arrayOAB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOB, arrayOAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Int50",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setY, arrayXY, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setY, arrayXY]) }),
  BenchmarkInfo(
    name: "Set.isStrictSubset.Seq.Int100",
    runFunction: { n in run_SetIsStrictSubsetSeqInt(setP, arrayP, false, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setP, arrayP]) }),

  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Empty.Int",
    runFunction: { n in run_SetIsSupersetSeqInt(setAB, arrayE, true, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayE]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Int.Empty",
    runFunction: { n in run_SetIsSupersetSeqInt(setE, arrayAB, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setE, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Int0",
    runFunction: { n in run_SetIsSupersetSeqInt(setCD, arrayAB, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setCD, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Box0",
    runFunction: { n in run_SetIsSupersetSeqBox(setOCD, arrayOAB, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOCD, arrayOAB]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Int25",
    runFunction: { n in run_SetIsSupersetSeqInt(setAB, arrayB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayB]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Box25",
    runFunction: { n in run_SetIsSupersetSeqBox(setOAB, arrayOB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOAB, arrayOB]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Int50",
    runFunction: { n in run_SetIsSupersetSeqInt(setXY, arrayY, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setXY, arrayY]) }),
  BenchmarkInfo(
    name: "Set.isSuperset.Seq.Int100",
    runFunction: { n in run_SetIsSupersetSeqInt(setP, arrayP, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setP, arrayP]) }),

  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Empty.Int",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setAB, arrayE, true, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayE]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Int.Empty",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setE, arrayAB, false, 5000 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setE, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Int0",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setCD, arrayAB, false, 500 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setCD, arrayAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Box0",
    runFunction: { n in run_SetIsStrictSupersetSeqBox(setOCD, arrayOAB, false, 500 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOCD, arrayOAB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Int25",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setAB, arrayB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setAB, arrayB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Box25",
    runFunction: { n in run_SetIsStrictSupersetSeqBox(setOAB, arrayOB, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setOAB, arrayOB]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Int50",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setXY, arrayY, true, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setXY, arrayY]) }),
  BenchmarkInfo(
    name: "Set.isStrictSuperset.Seq.Int100",
    runFunction: { n in run_SetIsStrictSupersetSeqInt(setP, arrayP, false, 50 * n) },
    tags: [.validation, .api, .Set],
    setUpFunction: { blackHole([setP, arrayP]) }),

  BenchmarkInfo(
    name: "Set.isDisjoint.Empty.Int",
