     ])) } }, tags: d),
 
   BenchmarkInfo(name: "DataSubscriptSmall",
-    runFunction: { for _ in 0..<$0*10_000 { blackHole(small[1]) } }, tags: d),
+    runFunction: { for _ in 0..<$0*M { blackHole(small[1]) } }, tags: d),
   BenchmarkInfo(name: "DataSubscriptMedium",
-    runFunction: { for _ in 0..<$0*10_000 { blackHole(medium[521]) } }, tags: d),
+    runFunction: { for _ in 0..<$0*M { blackHole(medium[521]) } }, tags: d),
 
   BenchmarkInfo(name: "DataCountSmall",
-    runFunction: { count($0, data: small) }, tags: d),
+    runFunction: { count($0*M, data: small) }, tags: d),
   BenchmarkInfo(name: "DataCountMedium",
-    runFunction: { count($0, data: medium) }, tags: d),
+    runFunction: { count($0*M, data: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataSetCountSmall",
-    runFunction: { setCount($0, data: small, extra: 3) }, tags: d),
+    runFunction: { setCount($0*M, data: small, extra: 3) }, tags: d),
   BenchmarkInfo(name: "DataSetCountMedium",
-    runFunction: { setCount($0, data: medium, extra: 100) }, tags: d),
+    runFunction: { setCount($0*M, data: medium, extra: 100) }, tags: d),
 
   BenchmarkInfo(name: "DataAccessBytesSmall",
-    runFunction: { withUnsafeBytes($0, data: small) }, tags: d),
+    runFunction: { withUnsafeBytes($0*M, data: small) }, tags: d),
   BenchmarkInfo(name: "DataAccessBytesMedium",
-    runFunction: { withUnsafeBytes($0, data: medium) }, tags: d),
+    runFunction: { withUnsafeBytes($0*M, data: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataMutateBytesSmall",
-    runFunction: { withUnsafeMutableBytes($0, data: small) }, tags: d),
+    runFunction: { withUnsafeMutableBytes($0*M, data: small) }, tags: d),
   BenchmarkInfo(name: "DataMutateBytesMedium",
-    runFunction: { withUnsafeMutableBytes($0, data: medium) }, tags: d),
+    runFunction: { withUnsafeMutableBytes($0*M, data: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataCopyBytesSmall",
-    runFunction: { copyBytes($0, data: small) }, tags: d),
+    runFunction: { copyBytes($0*M, data: small) }, tags: d),
   BenchmarkInfo(name: "DataCopyBytesMedium",
-    runFunction: { copyBytes($0, data: medium) }, tags: d),
+    runFunction: { copyBytes($0*M, data: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataAppendBytesSmall",
-    runFunction: { append($0, bytes: 3, to: small) }, tags: d),
+    runFunction: { append($0*M, bytes: 3, to: small) }, tags: d),
   BenchmarkInfo(name: "DataAppendBytesMedium",
-    runFunction: { append($0, bytes: 809, to: medium) }, tags: d),
+    runFunction: { append($0*M, bytes: 809, to: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataAppendArray",
-    runFunction: { append($0, arraySize: 809, to: medium) }, tags: d),
+    runFunction: { append($0*M, arraySize: 809, to: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataReset",
-    runFunction: { resetBytes($0, in: 431..<809, data: medium) }, tags: d),
+    runFunction: { resetBytes($0*M, in: 431..<809, data: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataReplaceSmall", runFunction: {
-    replace($0, data: medium, subrange:431..<809, with: small) }, tags: d),
+    replace($0*M, data: medium, subrange:431..<809, with: small) }, tags: d),
   BenchmarkInfo(name: "DataReplaceMedium", runFunction: {
-    replace($0, data: medium, subrange:431..<809, with: medium) }, tags: d),
+    replace($0*M, data: medium, subrange:431..<809, with: medium) }, tags: d),
   BenchmarkInfo(name: "DataReplaceLarge", runFunction: {
-    replace($0, data: medium, subrange:431..<809, with: large) }, tags: d),
+    replace($0*M, data: medium, subrange:431..<809, with: large) }, tags: d),
 
   BenchmarkInfo(name: "DataReplaceSmallBuffer", runFunction: {
-    replaceBuffer($0, data: medium, subrange:431..<809, with: small) },
+    replaceBuffer($0*M, data: medium, subrange:431..<809, with: small) },
     tags: d),
   BenchmarkInfo(name: "DataReplaceMediumBuffer", runFunction: {
-    replaceBuffer($0, data: medium, subrange:431..<809, with: medium) },
+    replaceBuffer($0*M, data: medium, subrange:431..<809, with: medium) },
     tags: d),
   BenchmarkInfo(name: "DataReplaceLargeBuffer", runFunction: {
-    replaceBuffer($0, data: medium, subrange:431..<809, with: large) },
+    replaceBuffer($0*M, data: medium, subrange:431..<809, with: large) },
     tags: d),
 
   BenchmarkInfo(name: "DataAppendSequence",
-    runFunction: { append($0, sequenceLength: 809, to: medium) }, tags: d),
+    runFunction: { append($0*M, sequenceLength: 809, to: medium) }, tags: d),
 
   BenchmarkInfo(name: "DataAppendDataSmallToSmall",
-    runFunction: { append($0, data: small, to: small) }, tags: d),
+    runFunction: { append($0*M, data: small, to: small) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataSmallToMedium",
-    runFunction: { append($0, data: small, to: medium) }, tags: d),
+    runFunction: { append($0*M, data: small, to: medium) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataSmallToLarge",
-    runFunction: { append($0, data: small, to: large) }, tags: d),
+    runFunction: { append($0*M, data: small, to: large) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataMediumToSmall",
-    runFunction: { append($0, data: medium, to: small) }, tags: d),
+    runFunction: { append($0*M, data: medium, to: small) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataMediumToMedium",
-    runFunction: { append($0, data: medium, to: medium) }, tags: d),
+    runFunction: { append($0*M, data: medium, to: medium) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataMediumToLarge",
-    runFunction: { append($0, data: medium, to: large) }, tags: d),
+    runFunction: { append($0*M, data: medium, to: large) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataLargeToSmall",
-    runFunction: { append($0, data: large, to: small) }, tags: d),
+    runFunction: { append($0*M, data: large, to: small) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataLargeToMedium",
-    runFunction: { append($0, data: large, to: medium) }, tags: d),
+    runFunction: { append($0*M, data: large, to: medium) }, tags: d),
   BenchmarkInfo(name: "DataAppendDataLargeToLarge",
-    runFunction: { append($0, data: large, to: large) }, tags: d),
+    runFunction: { append($0*M, data: large, to: large) }, tags: d),
 
   BenchmarkInfo(name: "DataToStringEmpty",
-    runFunction: { string($0, from: emptyData) }, tags: d, legacyFactor: 50),
+    runFunction: { string($0*S, from: emptyData) }, tags: d, legacyFactor: 50),
   BenchmarkInfo(name: "DataToStringSmall",
-    runFunction: { string($0, from: smallData) }, tags: d, legacyFactor: 50),
+    runFunction: { string($0*S, from: smallData) }, tags: d, legacyFactor: 50),
   BenchmarkInfo(name: "DataToStringMedium",
-    runFunction: { string($0, from: mediumData) }, tags: d, legacyFactor: 50),
+    runFunction: { string($0*S, from: mediumData) }, tags: d, legacyFactor: 50),
 
   BenchmarkInfo(name: "StringToDataEmpty",
-    runFunction: { data($0, from: emptyString) }, tags: d, legacyFactor: 50),
+    runFunction: { data($0*S, from: emptyString) }, tags: d, legacyFactor: 50),
   BenchmarkInfo(name: "StringToDataSmall",
-    runFunction: { data($0, from: smallString) }, tags: d, legacyFactor: 50),
+    runFunction: { data($0*S, from: smallString) }, tags: d, legacyFactor: 50),
   BenchmarkInfo(name: "StringToDataMedium",
-    runFunction: { data($0, from: mediumString) }, tags: d, legacyFactor: 50),
+    runFunction: { data($0*S, from: mediumString) }, tags: d, legacyFactor: 50),
 ]
 
 let emptyString = ""

  bytes.withUnsafeMutableBufferPointer {
    fillBuffer($0)
  }
  for _ in 0..<10000*N {
    var copy = data
    copy.append(contentsOf: bytes)
  }

@inline(never)
func append(_ N: Int, sequenceLength: Int, to data: Data) {
  let bytes = repeatElement(UInt8(0xA0), count: sequenceLength)
  for _ in 1...N {
    var copy = data
    copy.append(contentsOf: bytes)
  }
