 }
 
 @inline(never)
+public func run_SetIsStrictSubsetSeqInt(
+  _ a: Set<Int>,
+  _ b: Array<Int>,
+  _ r: Bool,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let isStrictSubset = a.isStrictSubset(of: identity(b))
+    CheckResults(isStrictSubset == r)
+  }
+}
+
+@inline(never)
+public func run_SetIsSupersetSeqInt(
+  _ a: Set<Int>,
+  _ b: Array<Int>,
+  _ r: Bool,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let isSuperset = a.isSuperset(of: identity(b))
+    CheckResults(isSuperset == r)
+  }
+}
+
+@inline(never)
+public func run_SetIsStrictSupersetSeqInt(
+  _ a: Set<Int>,
+  _ b: Array<Int>,
+  _ r: Bool,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let isStrictSuperset = a.isStrictSuperset(of: identity(b))
+    CheckResults(isStrictSuperset == r)
+  }
+}
+
+@inline(never)
 public func run_SetSymmetricDifferenceInt(
   _ a: Set<Int>,
   _ b: Set<Int>,

  return set
}()

public let SetTests = [
  // Mnemonic: number after name is percentage of common elements in input sets.
  BenchmarkInfo(

    setUpFunction: { blackHole([setP, setQ]) }),

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

  BenchmarkInfo(
    name: "SetSymmetricDifferenceInt0",
    runFunction: { n in run_SetSymmetricDifferenceInt(setAB, setCD, countABCD, 10 * n) },
    tags: [.validation, .api, .Set],
