diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 010bf08b79164..047a0f5255e12 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -44,7 +44,9 @@ set(SWIFT_BENCH_MODULES
     single-source/DictionaryLiteral
     single-source/DictionaryRemove
     single-source/DictionarySwap
+    single-source/DropFirst
     single-source/DropLast
+    single-source/DropWhile
     single-source/ErrorHandling
     single-source/ExistentialPerformance
     single-source/Fibonacci
@@ -79,6 +81,8 @@ set(SWIFT_BENCH_MODULES
     single-source/PolymorphicCalls
     single-source/PopFront
     single-source/PopFrontGeneric
+    single-source/Prefix
+    single-source/PrefixWhile
     single-source/Prims
     single-source/ProtocolDispatch
     single-source/ProtocolDispatch2
diff --git a/benchmark/scripts/generate_harness/generate_harness.py b/benchmark/scripts/generate_harness/generate_harness.py
index 527e40e8fd25f..cb320588c0ea5 100755
--- a/benchmark/scripts/generate_harness/generate_harness.py
+++ b/benchmark/scripts/generate_harness/generate_harness.py
@@ -12,24 +12,32 @@
 #
 # ===---------------------------------------------------------------------===//
 
-# Generate CMakeLists.txt and utils/main.swift from templates.
+# Generate boilerplate, CMakeLists.txt and utils/main.swift from templates.
 
 from __future__ import print_function
 
-import glob
+import argparse
 import os
 import re
+import subprocess
 
 import jinja2
 
 script_dir = os.path.dirname(os.path.realpath(__file__))
 perf_dir = os.path.realpath(os.path.join(script_dir, '../..'))
+gyb = os.path.realpath(os.path.join(perf_dir, '../utils/gyb'))
 single_source_dir = os.path.join(perf_dir, 'single-source')
 multi_source_dir = os.path.join(perf_dir, 'multi-source')
+parser = argparse.ArgumentParser()
+parser.add_argument("--output-dir",
+                    help="Output directory (for validation test)",
+                    default=perf_dir)
+args = parser.parse_args()
+output_dir = args.output_dir
 
 template_map = {
-    'CMakeLists.txt_template': os.path.join(perf_dir, 'CMakeLists.txt'),
-    'main.swift_template': os.path.join(perf_dir, 'utils/main.swift')
+    'CMakeLists.txt_template': os.path.join(output_dir, 'CMakeLists.txt'),
+    'main.swift_template': os.path.join(output_dir, 'utils/main.swift')
 }
 ignored_run_funcs = ["Ackermann", "Fibonacci"]
 
@@ -37,18 +45,42 @@
 template_env = jinja2.Environment(loader=template_loader, trim_blocks=True,
                                   lstrip_blocks=True)
 
+
+def all_files(directory, extension):  # matching: [directory]/**/*[extension]
+    return [
+        os.path.join(root, f)
+        for root, _, files in os.walk(directory)
+        for f in files if f.endswith(extension)
+    ]
+
+
+def will_write(filename):  # ensure path to file exists before writing
+    print(filename)
+    output_path = os.path.split(filename)[0]
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+
+
 if __name__ == '__main__':
+    # Generate Your Boilerplate
+    gyb_files = all_files(perf_dir, '.gyb')
+    for f in gyb_files:
+        relative_path = os.path.relpath(f[:-4], perf_dir)
+        out_file = os.path.join(output_dir, relative_path)
+        will_write(out_file)
+        subprocess.call([gyb, '--line-directive', '', '-o', out_file, f])
+
     # CMakeList single-source
-    test_files = glob.glob(os.path.join(single_source_dir, '*.swift'))
+    test_files = all_files(single_source_dir, '.swift')
     tests = sorted(os.path.basename(x).split('.')[0] for x in test_files)
 
     # CMakeList multi-source
     class MultiSourceBench(object):
-
         def __init__(self, path):
             self.name = os.path.basename(path)
             self.files = [x for x in os.listdir(path)
                           if x.endswith('.swift')]
+
     if os.path.isdir(multi_source_dir):
         multisource_benches = [
             MultiSourceBench(os.path.join(multi_source_dir, x))
@@ -67,26 +99,19 @@ def get_run_funcs(filepath):
         matches = re.findall(r'func run_(.*?)\(', content)
         return filter(lambda x: x not in ignored_run_funcs, matches)
 
-    def find_run_funcs(dirs):
-        ret_run_funcs = []
-        for d in dirs:
-            for root, _, files in os.walk(d):
-                for name in filter(lambda x: x.endswith('.swift'), files):
-                    run_funcs = get_run_funcs(os.path.join(root, name))
-                    ret_run_funcs.extend(run_funcs)
-        return ret_run_funcs
-    run_funcs = sorted(
-        [(x, x)
-         for x in find_run_funcs([single_source_dir, multi_source_dir])],
-        key=lambda x: x[0]
-    )
+    def find_run_funcs():
+        swift_files = all_files(perf_dir, '.swift')
+        return [func for f in swift_files for func in get_run_funcs(f)]
+
+    run_funcs = [(f, f) for f in sorted(find_run_funcs())]
 
     # Replace originals with files generated from templates
     for template_file in template_map:
         template_path = os.path.join(script_dir, template_file)
         template = template_env.get_template(template_path)
-        print(template_map[template_file])
-        open(template_map[template_file], 'w').write(
+        out_file = template_map[template_file]
+        will_write(out_file)
+        open(out_file, 'w').write(
             template.render(tests=tests,
                             multisource_benches=multisource_benches,
                             imports=imports,
diff --git a/benchmark/scripts/generate_harness/test_generate_harness.sh b/benchmark/scripts/generate_harness/test_generate_harness.sh
new file mode 100755
index 0000000000000..03421c29968b6
--- /dev/null
+++ b/benchmark/scripts/generate_harness/test_generate_harness.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# This script is invoked by `lit` on all smoke test runs from the
+# validation-test/benchmark/generate-harness.test-sh.
+# It ensures that the files checked in the benchmark suite that are generated
+# from templates always match what would be regenerated if one
+# re-ran the relevant scripts. This is to catch accidental manual edits.
+
+SWIFT_SRC_DIR="$1"
+BENCHMARK_DIR="${SWIFT_SRC_DIR}/benchmark"
+SCRIPT_DIR="${BENCHMARK_DIR}/scripts"
+TEMP_DIR="$2"
+
+"${SCRIPT_DIR}/generate_harness/generate_harness.py" "--output-dir=${TEMP_DIR}"
+for f in $(cd "${TEMP_DIR}" && find ./ -type f); do
+    diff "${TEMP_DIR}/${f}" "${BENCHMARK_DIR}/${f}"
+    if [[ $? -ne 0 ]]; then
+       exit 1
+    fi
+done
diff --git a/benchmark/single-source/DropFirst.swift b/benchmark/single-source/DropFirst.swift
new file mode 100644
index 0000000000000..cc25cee28fc56
--- /dev/null
+++ b/benchmark/single-source/DropFirst.swift
@@ -0,0 +1,193 @@
+//===--- DropFirst.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropFirst.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let dropCount = 1024
+let suffixCount = sequenceCount - dropCount
+let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+
+@inline(never)
+public func run_DropFirstCountableRange(_ N: Int) {
+  let s = 0..<sequenceCount
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstCountableRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstSequence(_ N: Int) {
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstSequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySequence(_ N: Int) {
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnyCollection: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstArray(_ N: Int) {
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropFirstArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirstArrayLazy: \(result) != \(sumCount)")
+  }
+}
diff --git a/benchmark/single-source/DropFirst.swift.gyb b/benchmark/single-source/DropFirst.swift.gyb
new file mode 100644
index 0000000000000..c004ea094c451
--- /dev/null
+++ b/benchmark/single-source/DropFirst.swift.gyb
@@ -0,0 +1,58 @@
+//===--- DropFirst.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropFirst.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let dropCount = 1024
+let suffixCount = sequenceCount - dropCount
+let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+%{
+# Name and Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_DropFirst${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropFirst(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropFirst${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/single-source/DropLast.swift b/benchmark/single-source/DropLast.swift
index bce532c200d07..c89d017fd5f92 100644
--- a/benchmark/single-source/DropLast.swift
+++ b/benchmark/single-source/DropLast.swift
@@ -10,77 +10,184 @@
 //
 //===----------------------------------------------------------------------===//
 
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropLast.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
 import TestsUtils
 
-let reps = 1
 let sequenceCount = 4096
 let prefixCount = 1024
 let dropCount = sequenceCount - prefixCount
-let sumCount = prefixCount * (prefixCount-1) / 2
+let sumCount = prefixCount * (prefixCount - 1) / 2
 
 @inline(never)
 public func run_DropLastCountableRange(_ N: Int) {
-  let s = 0 ..< sequenceCount
+  let s = 0..<sequenceCount
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.dropLast(dropCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in DropLastCountableRange: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastCountableRange: \(result) != \(sumCount)")
   }
 }
-
-fileprivate struct MySequence: Sequence {
-  let range: CountableRange<Int>
-  public func makeIterator() -> IndexingIterator<CountableRange<Int>> {
-      return range.makeIterator()
-  }
-}
-
 @inline(never)
 public func run_DropLastSequence(_ N: Int) {
-  let s = MySequence(range: 0 ..< sequenceCount)
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.dropLast(dropCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in DropLastSequence: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastSequence: \(result) != \(sumCount)")
   }
 }
-
 @inline(never)
 public func run_DropLastAnySequence(_ N: Int) {
-  let s = AnySequence(0 ..< sequenceCount)
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.dropLast(dropCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in DropLastAnySequence: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnyCollection: \(result) != \(sumCount)")
   }
 }
-
 @inline(never)
 public func run_DropLastArray(_ N: Int) {
-  let s = Array(0 ..< sequenceCount)
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropLastArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.dropLast(dropCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in DropLastArray: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLastArrayLazy: \(result) != \(sumCount)")
   }
 }
diff --git a/benchmark/single-source/DropLast.swift.gyb b/benchmark/single-source/DropLast.swift.gyb
new file mode 100644
index 0000000000000..697925aecb463
--- /dev/null
+++ b/benchmark/single-source/DropLast.swift.gyb
@@ -0,0 +1,58 @@
+//===--- DropLast.swift ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropLast.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let prefixCount = 1024
+let dropCount = sequenceCount - prefixCount
+let sumCount = prefixCount * (prefixCount - 1) / 2
+%{
+# Name and Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_DropLast${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.dropLast(dropCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropLast${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/single-source/DropWhile.swift b/benchmark/single-source/DropWhile.swift
new file mode 100644
index 0000000000000..2b377020d2fa6
--- /dev/null
+++ b/benchmark/single-source/DropWhile.swift
@@ -0,0 +1,193 @@
+//===--- DropWhile.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropWhile.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let dropCount = 1024
+let suffixCount = sequenceCount - dropCount
+let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+
+@inline(never)
+public func run_DropWhileCountableRange(_ N: Int) {
+  let s = 0..<sequenceCount
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileCountableRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileSequence(_ N: Int) {
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileSequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySequence(_ N: Int) {
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnyCollection: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileArray(_ N: Int) {
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_DropWhileArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhileArrayLazy: \(result) != \(sumCount)")
+  }
+}
diff --git a/benchmark/single-source/DropWhile.swift.gyb b/benchmark/single-source/DropWhile.swift.gyb
new file mode 100644
index 0000000000000..b8ef12f7b90c0
--- /dev/null
+++ b/benchmark/single-source/DropWhile.swift.gyb
@@ -0,0 +1,58 @@
+//===--- DropWhile.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to DropWhile.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let dropCount = 1024
+let suffixCount = sequenceCount - dropCount
+let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+%{
+# Name and Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_DropWhile${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.drop(while: {$0 < dropCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in DropWhile${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/single-source/Prefix.swift b/benchmark/single-source/Prefix.swift
new file mode 100644
index 0000000000000..e375ab9a5a9c1
--- /dev/null
+++ b/benchmark/single-source/Prefix.swift
@@ -0,0 +1,192 @@
+//===--- Prefix.swift -----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to Prefix.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let prefixCount = sequenceCount - 1024
+let sumCount = prefixCount * (prefixCount - 1) / 2
+
+@inline(never)
+public func run_PrefixCountableRange(_ N: Int) {
+  let s = 0..<sequenceCount
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixCountableRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixSequence(_ N: Int) {
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixSequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySequence(_ N: Int) {
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnyCollection: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixArray(_ N: Int) {
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixArrayLazy: \(result) != \(sumCount)")
+  }
+}
diff --git a/benchmark/single-source/Prefix.swift.gyb b/benchmark/single-source/Prefix.swift.gyb
new file mode 100644
index 0000000000000..f9c10c2cd2716
--- /dev/null
+++ b/benchmark/single-source/Prefix.swift.gyb
@@ -0,0 +1,57 @@
+//===--- Prefix.swift -----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to Prefix.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let prefixCount = sequenceCount - 1024
+let sumCount = prefixCount * (prefixCount - 1) / 2
+%{
+# Name and initializer Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_Prefix${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(prefixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in Prefix${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/single-source/PrefixWhile.swift b/benchmark/single-source/PrefixWhile.swift
new file mode 100644
index 0000000000000..480cfe706da33
--- /dev/null
+++ b/benchmark/single-source/PrefixWhile.swift
@@ -0,0 +1,192 @@
+//===--- PrefixWhile.swift ------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to PrefixWhile.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let prefixCount = sequenceCount - 1024
+let sumCount = prefixCount * (prefixCount - 1) / 2
+
+@inline(never)
+public func run_PrefixWhileCountableRange(_ N: Int) {
+  let s = 0..<sequenceCount
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileCountableRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileSequence(_ N: Int) {
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileSequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySequence(_ N: Int) {
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnyCollection: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileArray(_ N: Int) {
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_PrefixWhileArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhileArrayLazy: \(result) != \(sumCount)")
+  }
+}
diff --git a/benchmark/single-source/PrefixWhile.swift.gyb b/benchmark/single-source/PrefixWhile.swift.gyb
new file mode 100644
index 0000000000000..f276880c8dbc8
--- /dev/null
+++ b/benchmark/single-source/PrefixWhile.swift.gyb
@@ -0,0 +1,57 @@
+//===--- PrefixWhile.swift ------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to PrefixWhile.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let prefixCount = sequenceCount - 1024
+let sumCount = prefixCount * (prefixCount - 1) / 2
+%{
+# Name and initializer Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_PrefixWhile${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.prefix(while: {$0 < prefixCount} ) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in PrefixWhile${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/single-source/Suffix.swift b/benchmark/single-source/Suffix.swift
index e55043cc35531..4eb982af46927 100644
--- a/benchmark/single-source/Suffix.swift
+++ b/benchmark/single-source/Suffix.swift
@@ -1,4 +1,4 @@
-//===--- Suffix.swift ---------------------------------------------------===//
+//===--- Suffix.swift -----------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,76 +10,183 @@
 //
 //===----------------------------------------------------------------------===//
 
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to Suffix.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
 import TestsUtils
 
-let reps = 1
 let sequenceCount = 4096
 let suffixCount = 1024
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
 
 @inline(never)
 public func run_SuffixCountableRange(_ N: Int) {
-  let s = 0 ..< sequenceCount
+  let s = 0..<sequenceCount
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.suffix(suffixCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in SuffixCountableRange: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixCountableRange: \(result) != \(sumCount)")
   }
 }
-
-fileprivate struct MySequence: Sequence {
-  let range: CountableRange<Int>
-  public func makeIterator() -> IndexingIterator<CountableRange<Int>> {
-      return range.makeIterator()
-  }
-}
-
 @inline(never)
 public func run_SuffixSequence(_ N: Int) {
-  let s = MySequence(range: 0 ..< sequenceCount)
+  let s = sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.suffix(suffixCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in SuffixSequence: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixSequence: \(result) != \(sumCount)")
   }
 }
-
 @inline(never)
 public func run_SuffixAnySequence(_ N: Int) {
-  let s = AnySequence(0 ..< sequenceCount)
+  let s = AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.suffix(suffixCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in SuffixAnySequence: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySequence: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnySeqCntRange(_ N: Int) {
+  let s = AnySequence(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySeqCntRange: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnySeqCRangeIter(_ N: Int) {
+  let s = AnySequence((0..<sequenceCount).makeIterator())
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySeqCRangeIter: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnyCollection(_ N: Int) {
+  let s = AnyCollection(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnyCollection: \(result) != \(sumCount)")
   }
 }
-
 @inline(never)
 public func run_SuffixArray(_ N: Int) {
-  let s = Array(0 ..< sequenceCount)
+  let s = Array(0..<sequenceCount)
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixArray: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixCountableRangeLazy(_ N: Int) {
+  let s = (0..<sequenceCount).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixCountableRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixSequenceLazy(_ N: Int) {
+  let s = (sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixSequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnySequenceLazy(_ N: Int) {
+  let s = (AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySequenceLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnySeqCntRangeLazy(_ N: Int) {
+  let s = (AnySequence(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySeqCntRangeLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnySeqCRangeIterLazy(_ N: Int) {
+  let s = (AnySequence((0..<sequenceCount).makeIterator())).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnySeqCRangeIterLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixAnyCollectionLazy(_ N: Int) {
+  let s = (AnyCollection(0..<sequenceCount)).lazy
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixAnyCollectionLazy: \(result) != \(sumCount)")
+  }
+}
+@inline(never)
+public func run_SuffixArrayLazy(_ N: Int) {
+  let s = (Array(0..<sequenceCount)).lazy
   for _ in 1...20*N {
-    for _ in 1...reps {
-      var result = 0
-      for element in s.suffix(suffixCount) {
-        result += element
-      }
-      CheckResults(result == sumCount, 
-        "IncorrectResults in SuffixArray: \(result) != \(sumCount)")
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
     }
+    CheckResults(result == sumCount,
+      "IncorrectResults in SuffixArrayLazy: \(result) != \(sumCount)")
   }
 }
diff --git a/benchmark/single-source/Suffix.swift.gyb b/benchmark/single-source/Suffix.swift.gyb
new file mode 100644
index 0000000000000..87a65fed36439
--- /dev/null
+++ b/benchmark/single-source/Suffix.swift.gyb
@@ -0,0 +1,57 @@
+//===--- Suffix.swift -----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+% # Ignore the following warning. This _is_ the correct file to edit.
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from .gyb template and should not
+// be directly modified. Instead, make changes to Suffix.swift.gyb and run
+// scripts/generate_harness/generate_harness.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
+
+import TestsUtils
+
+let sequenceCount = 4096
+let suffixCount = 1024
+let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+%{
+# Name and initializer Expression pairs for Sequences to test.
+
+Sequences = [
+  ('CountableRange', '0..<sequenceCount'),
+  ('Sequence',
+    'sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil }'),
+  ('AnySequence',
+    'AnySequence(sequence(first: 0) { $0 < sequenceCount - 1 ? $0 &+ 1 : nil })'),
+  ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
+  ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
+  ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
+  ('Array', 'Array(0..<sequenceCount)'),
+]
+def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
+
+Sequences = Sequences + map(lazy, Sequences)
+}%
+
+% for (Name, Expr) in Sequences:
+@inline(never)
+public func run_Suffix${Name}(_ N: Int) {
+  let s = ${Expr}
+  for _ in 1...20*N {
+    var result = 0
+    for element in s.suffix(suffixCount) {
+      result += element
+    }
+    CheckResults(result == sumCount,
+      "IncorrectResults in Suffix${Name}: \(result) != \(sumCount)")
+  }
+}
+% end
diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift
index 9caad7b229870..ab24421f55571 100644
--- a/benchmark/utils/main.swift
+++ b/benchmark/utils/main.swift
@@ -49,7 +49,9 @@ import DictionaryBridge
 import DictionaryLiteral
 import DictionaryRemove
 import DictionarySwap
+import DropFirst
 import DropLast
+import DropWhile
 import ErrorHandling
 import ExistentialPerformance
 import Fibonacci
@@ -84,6 +86,8 @@ import Phonebook
 import PolymorphicCalls
 import PopFront
 import PopFrontGeneric
+import Prefix
+import PrefixWhile
 import Prims
 import ProtocolDispatch
 import ProtocolDispatch2
@@ -172,10 +176,48 @@ precommitTests = [
   "DictionaryRemoveOfObjects": run_DictionaryRemoveOfObjects,
   "DictionarySwap": run_DictionarySwap,
   "DictionarySwapOfObjects": run_DictionarySwapOfObjects,
+  "DropFirstAnyCollection": run_DropFirstAnyCollection,
+  "DropFirstAnyCollectionLazy": run_DropFirstAnyCollectionLazy,
+  "DropFirstAnySeqCRangeIter": run_DropFirstAnySeqCRangeIter,
+  "DropFirstAnySeqCRangeIterLazy": run_DropFirstAnySeqCRangeIterLazy,
+  "DropFirstAnySeqCntRange": run_DropFirstAnySeqCntRange,
+  "DropFirstAnySeqCntRangeLazy": run_DropFirstAnySeqCntRangeLazy,
+  "DropFirstAnySequence": run_DropFirstAnySequence,
+  "DropFirstAnySequenceLazy": run_DropFirstAnySequenceLazy,
+  "DropFirstArray": run_DropFirstArray,
+  "DropFirstArrayLazy": run_DropFirstArrayLazy,
+  "DropFirstCountableRange": run_DropFirstCountableRange,
+  "DropFirstCountableRangeLazy": run_DropFirstCountableRangeLazy,
+  "DropFirstSequence": run_DropFirstSequence,
+  "DropFirstSequenceLazy": run_DropFirstSequenceLazy,
+  "DropLastAnyCollection": run_DropLastAnyCollection,
+  "DropLastAnyCollectionLazy": run_DropLastAnyCollectionLazy,
+  "DropLastAnySeqCRangeIter": run_DropLastAnySeqCRangeIter,
+  "DropLastAnySeqCRangeIterLazy": run_DropLastAnySeqCRangeIterLazy,
+  "DropLastAnySeqCntRange": run_DropLastAnySeqCntRange,
+  "DropLastAnySeqCntRangeLazy": run_DropLastAnySeqCntRangeLazy,
   "DropLastAnySequence": run_DropLastAnySequence,
+  "DropLastAnySequenceLazy": run_DropLastAnySequenceLazy,
   "DropLastArray": run_DropLastArray,
+  "DropLastArrayLazy": run_DropLastArrayLazy,
   "DropLastCountableRange": run_DropLastCountableRange,
+  "DropLastCountableRangeLazy": run_DropLastCountableRangeLazy,
   "DropLastSequence": run_DropLastSequence,
+  "DropLastSequenceLazy": run_DropLastSequenceLazy,
+  "DropWhileAnyCollection": run_DropWhileAnyCollection,
+  "DropWhileAnyCollectionLazy": run_DropWhileAnyCollectionLazy,
+  "DropWhileAnySeqCRangeIter": run_DropWhileAnySeqCRangeIter,
+  "DropWhileAnySeqCRangeIterLazy": run_DropWhileAnySeqCRangeIterLazy,
+  "DropWhileAnySeqCntRange": run_DropWhileAnySeqCntRange,
+  "DropWhileAnySeqCntRangeLazy": run_DropWhileAnySeqCntRangeLazy,
+  "DropWhileAnySequence": run_DropWhileAnySequence,
+  "DropWhileAnySequenceLazy": run_DropWhileAnySequenceLazy,
+  "DropWhileArray": run_DropWhileArray,
+  "DropWhileArrayLazy": run_DropWhileArrayLazy,
+  "DropWhileCountableRange": run_DropWhileCountableRange,
+  "DropWhileCountableRangeLazy": run_DropWhileCountableRangeLazy,
+  "DropWhileSequence": run_DropWhileSequence,
+  "DropWhileSequenceLazy": run_DropWhileSequenceLazy,
   "ErrorHandling": run_ErrorHandling,
   "ExistentialTestArrayConditionalShift_ClassValueBuffer1": run_ExistentialTestArrayConditionalShift_ClassValueBuffer1,
   "ExistentialTestArrayConditionalShift_ClassValueBuffer2": run_ExistentialTestArrayConditionalShift_ClassValueBuffer2,
@@ -353,6 +395,34 @@ precommitTests = [
   "PopFrontArray": run_PopFrontArray,
   "PopFrontArrayGeneric": run_PopFrontArrayGeneric,
   "PopFrontUnsafePointer": run_PopFrontUnsafePointer,
+  "PrefixAnyCollection": run_PrefixAnyCollection,
+  "PrefixAnyCollectionLazy": run_PrefixAnyCollectionLazy,
+  "PrefixAnySeqCRangeIter": run_PrefixAnySeqCRangeIter,
+  "PrefixAnySeqCRangeIterLazy": run_PrefixAnySeqCRangeIterLazy,
+  "PrefixAnySeqCntRange": run_PrefixAnySeqCntRange,
+  "PrefixAnySeqCntRangeLazy": run_PrefixAnySeqCntRangeLazy,
+  "PrefixAnySequence": run_PrefixAnySequence,
+  "PrefixAnySequenceLazy": run_PrefixAnySequenceLazy,
+  "PrefixArray": run_PrefixArray,
+  "PrefixArrayLazy": run_PrefixArrayLazy,
+  "PrefixCountableRange": run_PrefixCountableRange,
+  "PrefixCountableRangeLazy": run_PrefixCountableRangeLazy,
+  "PrefixSequence": run_PrefixSequence,
+  "PrefixSequenceLazy": run_PrefixSequenceLazy,
+  "PrefixWhileAnyCollection": run_PrefixWhileAnyCollection,
+  "PrefixWhileAnyCollectionLazy": run_PrefixWhileAnyCollectionLazy,
+  "PrefixWhileAnySeqCRangeIter": run_PrefixWhileAnySeqCRangeIter,
+  "PrefixWhileAnySeqCRangeIterLazy": run_PrefixWhileAnySeqCRangeIterLazy,
+  "PrefixWhileAnySeqCntRange": run_PrefixWhileAnySeqCntRange,
+  "PrefixWhileAnySeqCntRangeLazy": run_PrefixWhileAnySeqCntRangeLazy,
+  "PrefixWhileAnySequence": run_PrefixWhileAnySequence,
+  "PrefixWhileAnySequenceLazy": run_PrefixWhileAnySequenceLazy,
+  "PrefixWhileArray": run_PrefixWhileArray,
+  "PrefixWhileArrayLazy": run_PrefixWhileArrayLazy,
+  "PrefixWhileCountableRange": run_PrefixWhileCountableRange,
+  "PrefixWhileCountableRangeLazy": run_PrefixWhileCountableRangeLazy,
+  "PrefixWhileSequence": run_PrefixWhileSequence,
+  "PrefixWhileSequenceLazy": run_PrefixWhileSequenceLazy,
   "Prims": run_Prims,
   "ProtocolDispatch": run_ProtocolDispatch,
   "ProtocolDispatch2": run_ProtocolDispatch2,
@@ -396,10 +466,20 @@ precommitTests = [
   "StringUTF16Builder": run_StringUTF16Builder,
   "StringWalk": run_StringWalk,
   "StringWithCString": run_StringWithCString,
+  "SuffixAnyCollection": run_SuffixAnyCollection,
+  "SuffixAnyCollectionLazy": run_SuffixAnyCollectionLazy,
+  "SuffixAnySeqCRangeIter": run_SuffixAnySeqCRangeIter,
+  "SuffixAnySeqCRangeIterLazy": run_SuffixAnySeqCRangeIterLazy,
+  "SuffixAnySeqCntRange": run_SuffixAnySeqCntRange,
+  "SuffixAnySeqCntRangeLazy": run_SuffixAnySeqCntRangeLazy,
   "SuffixAnySequence": run_SuffixAnySequence,
+  "SuffixAnySequenceLazy": run_SuffixAnySequenceLazy,
   "SuffixArray": run_SuffixArray,
+  "SuffixArrayLazy": run_SuffixArrayLazy,
   "SuffixCountableRange": run_SuffixCountableRange,
+  "SuffixCountableRangeLazy": run_SuffixCountableRangeLazy,
   "SuffixSequence": run_SuffixSequence,
+  "SuffixSequenceLazy": run_SuffixSequenceLazy,
   "SuperChars": run_SuperChars,
   "TwoSum": run_TwoSum,
   "TypeFlood": run_TypeFlood,
diff --git a/test/lit.cfg b/test/lit.cfg
index a08a49e7f141e..d17c522189912 100644
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -354,6 +354,7 @@ ccp_opt = "-completion-cache-path %r" % completion_cache_path
 lit_config.note("Using code completion cache: " + completion_cache_path)
 
 config.substitutions.append( ('%swift_obj_root', config.swift_obj_root) )
+config.substitutions.append( ('%swift_src_root', config.swift_src_root) )
 config.substitutions.append( ('%{python}', sys.executable) )
 config.substitutions.append( ('%mcp_opt', mcp_opt) )
 config.substitutions.append( ('%swift_driver_plain', "%r" % config.swift) )
diff --git a/validation-test/benchmark/generate-harness.test-sh b/validation-test/benchmark/generate-harness.test-sh
new file mode 100644
index 0000000000000..a6c9175bbd47b
--- /dev/null
+++ b/validation-test/benchmark/generate-harness.test-sh
@@ -0,0 +1,5 @@
+// RUN: rm -rf %t
+// RUN: %swift_src_root/benchmark/scripts/generate_harness/test_generate_harness.sh %swift_src_root %t
+// REQUIRES: OS=macosx
+// REQUIRES: asserts
+// REQUIRES: CMAKE_GENERATOR=Ninja