diff --git a/MotionMark/developer.html b/MotionMark/developer.html
index b2de742..f095355 100644
--- a/MotionMark/developer.html
+++ b/MotionMark/developer.html
@@ -59,7 +59,12 @@ <h2>version <span class="version"></span></h2>
                     <div id="suites">
                         <h2>Suites:</h2>
                         <ul class="tree"></ul>
-                        <div><span id="drop-target">Drop results here</span></div>
+                        <div>
+                            <span id="drop-target">Drop results here</span>
+                            <button id="load-results-button" onclick="benchmarkController.loadResults()">Load results…</button>
+                            <input type="file" id="load-results-input" style="display: none;"
+                                onchange="benchmarkController.handleResultsFile(this)">
+                        </div>
                     </div>
                     <div id="options">
                         <h2>Options:</h2>
@@ -104,6 +109,16 @@ <h3>Adjusting the test complexity:</h3>
                                     <label>Target frame rate: <input type="number" id="frame-rate" value="60"> FPS</label>
                                 </li>
                                 <li>
+                                    <label>Score profile:
+                                        <select name="score-profile" id="score-profile">
+                                            <option value="slope">Slope</option>
+                                            <option value="flat">Flat</option>
+                                            <option value="window">Windowed</option>
+                                            <option value="window-strict">Windowed Strict</option>
+                                        </select>
+                                    </label>
+                                    </li>
+                                    <li>
                                     <h3>Time measurement method:</h3>
                                     <ul>
                                         <li><label><input name="time-measurement" type="radio" value="performance" checked> <code>performance.now()</code> (if available)</label></li>
@@ -147,6 +162,16 @@ <h1>MotionMark score</h1>
                 </div>
                 <div>version <span class="version"></span></div>
                 <p class="score" onclick="benchmarkController.showDebugInfo()"></p>
+                <div class="score-profile">
+                    <label>Score profile:
+                        <select id="results-score-profile" onchange="benchmarkController.changeScoreProfile(this.value)">
+                            <option value="slope">Slope</option>
+                            <option value="flat">Flat</option>
+                            <option value="window">Windowed</option>
+                            <option value="window-strict">Windowed Strict</option>
+                        </select>
+                    </label>
+                </div>
                 <p class="confidence"></p>
                 <div id="results-tables" class="table-container">
                     <div>
@@ -158,6 +183,7 @@ <h1>MotionMark score</h1>
                 <button onclick="benchmarkController.restartBenchmark()">Test Again</button>
                 <p>
                     'j': Show JSON results<br/>
+                    'd': Download JSON results<br/>
                     's': Select various results for copy/paste (use repeatedly to cycle)
                 </p>
             </div>
@@ -168,6 +194,16 @@ <h1>MotionMark score</h1>
                     <button onclick="benchmarkController.showResults()">&lt; Results</button>
                     <h1>Graph:</h1>
                     <p class="score">&nbsp;</p>
+                    <div class="score-profile">
+                        <label>Score profile:
+                            <select id="graph-score-profile" onchange="benchmarkController.changeScoreProfile(this.value)">
+                                <option value="slope">Slope</option>
+                                <option value="flat">Flat</option>
+                                <option value="window">Windowed</option>
+                                <option value="window-strict">Windowed Strict</option>
+                            </select>
+                        </label>
+                    </div>
                     <p class="confidence">&nbsp;</p>
                 </header>
                 <nav>
diff --git a/MotionMark/resources/debug-runner/debug-runner.js b/MotionMark/resources/debug-runner/debug-runner.js
index 085f4d3..5284978 100644
--- a/MotionMark/resources/debug-runner/debug-runner.js
+++ b/MotionMark/resources/debug-runner/debug-runner.js
@@ -587,28 +587,34 @@ class DebugBenchmarkController extends BenchmarkController {
             }
 
             dropTarget.textContent = 'Processing…';
+            this.handleResultsFile(e.dataTransfer.files[0]);
+        }, false);
+    }
 
-            var file = e.dataTransfer.files[0];
-
-            var reader = new FileReader();
-            reader.filename = file.name;
-            reader.onload = (e) => {
-                const data = JSON.parse(e.target.result);
-                
-                let results;
-                if (data['debugOutput'] instanceof Array)
-                    results = RunData.resultsDataFromBenchmarkRunnerData(data['debugOutput']);
-                else
-                    results = RunData.resultsDataFromSingleRunData(data);
+    loadResults() {
+        document.getElementById("load-results-input").click();
+    }
 
-                this.ensureRunnerClient([ ], { });
-                this.runnerClient.scoreCalculator = new ScoreCalculator(results);
-                this.showResults();
-            };
+    handleResultsFile(fileOrInput) {
+        var file = fileOrInput instanceof File ? fileOrInput : fileOrInput.files[0];
+        if (!file)
+            return;
 
-            reader.readAsText(file);
-            document.title = "File: " + reader.filename;
-        }, false);
+        var reader = new FileReader();
+        reader.filename = file.name;
+        reader.onload = (e) => {
+            const data = JSON.parse(e.target.result);
+            let results;
+            if (data['debugOutput'] instanceof Array)
+                results = RunData.resultsDataFromBenchmarkRunnerData(data['debugOutput']);
+            else
+                results = RunData.resultsDataFromSingleRunData(data);
+            this.ensureRunnerClient([], {});
+            this.runnerClient.scoreCalculator = new ScoreCalculator(results);
+            this.showResults();
+        };
+        reader.readAsText(file);
+        document.title = "File: " + reader.filename;
     }
 
     frameRateDeterminationComplete(targetFrameRate)
@@ -708,6 +714,15 @@ class DebugBenchmarkController extends BenchmarkController {
         const confidence = ((scoreCalculator.scoreLowerBound / score - 1) * 100).toFixed(2) +
             "% / +" + ((scoreCalculator.scoreUpperBound / score - 1) * 100).toFixed(2) + "%";
         const fps = scoreCalculator._systemFrameRate;
+
+        const resultsScoreProfileSelector = document.getElementById("results-score-profile");
+        if (resultsScoreProfileSelector)
+            resultsScoreProfileSelector.value = scoreCalculator.scoreProfile;
+
+        const graphScoreProfileSelector = document.getElementById("graph-score-profile");
+        if (graphScoreProfileSelector)
+            graphScoreProfileSelector.value = scoreCalculator.scoreProfile;
+
         sectionsManager.setSectionVersion("results", scoreCalculator.version);
         sectionsManager.setSectionScore("results", score.toFixed(2), confidence, fps);
         sectionsManager.populateTable("results-header", Headers.testName, scoreCalculator);
@@ -720,10 +735,41 @@ class DebugBenchmarkController extends BenchmarkController {
 
     showTestGraph(testName, testResult, testData)
     {
+        this._currentGraphParams = {
+            testName: testName,
+            testResult: testResult,
+            testData: testData
+        };
         sectionsManager.setSectionHeader("test-graph", testName);
         sectionsManager.showSection("test-graph", true);
         this.graphController.updateGraphData(testResult, testData, this.runnerClient.scoreCalculator.options);
     }
+
+    reloadCurrentGraph() {
+        if (!this._currentGraphParams)
+            return;
+
+        const scoreCalculator = this.runnerClient.scoreCalculator;
+        const testData = this._currentGraphParams.testData;
+        const testName = this._currentGraphParams.testName;
+
+        // find the updated testResult from scoreCalculator
+        let updatedTestResult = null;
+        scoreCalculator.results.forEach(iteration => {
+            for (let suiteName in iteration[Strings.json.results.tests]) {
+                const suite = iteration[Strings.json.results.tests][suiteName];
+                if (suite[testName]) {
+                    updatedTestResult = suite[testName];
+                    return;
+                }
+            }
+        });
+
+        if (updatedTestResult) {
+            this._currentGraphParams.testResult = updatedTestResult;
+            this.showTestGraph(testName, updatedTestResult, testData);
+        }
+    }
 }
 
 window.benchmarkControllerClass = DebugBenchmarkController;
diff --git a/MotionMark/resources/runner/motionmark.css b/MotionMark/resources/runner/motionmark.css
index 0ca5d75..b7b5889 100644
--- a/MotionMark/resources/runner/motionmark.css
+++ b/MotionMark/resources/runner/motionmark.css
@@ -37,6 +37,7 @@ body {
     cursor: default;
 
     -webkit-user-select: none;
+    user-select: none;
 }
 
 body.showing-intro,
@@ -152,6 +153,7 @@ section .body p {
     max-width: 60vw;
 
     -webkit-user-select: text;
+    user-select: text;
     cursor: text;
 }
 
@@ -428,6 +430,7 @@ body.large .frame-container {
 
 #results .body {
     -webkit-user-select: text;
+    user-select: text;
 }
 
 #results .score-container {
@@ -460,6 +463,24 @@ body.large .frame-container {
     padding-bottom: .3em;
 }
 
+#results .score-profile,
+#test-graph .score-profile {
+    font-size: 0.8em;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+}
+
+#results .score-profile label,
+#test-graph .score-profile label {
+    display: block;
+}
+
+#results .score-profile select,
+#test-graph .score-profile select {
+    font-family: inherit;
+    font-size: inherit;
+    margin-left: 0.5em;
+}
 #results table {
     border-spacing: 0;
     margin: 0;
@@ -541,10 +562,11 @@ body.large .detail .large {
     background: hsla(0, 0%, 100%, 0.9);
 }
 
-@supports (-webkit-backdrop-filter: blur(10px)) {
+@supports (-webkit-backdrop-filter: blur(10px)) or (backdrop-filter: blur(10px)) {
     #overlay {
         background: hsla(0, 0%, 100%, 0.7);
         -webkit-backdrop-filter: blur(20px);
+        backdrop-filter: blur(20px);
     }
 }
 
@@ -566,6 +588,7 @@ body.large .detail .large {
 
     font-size: 12px;
     -webkit-user-select: text;
+    user-select: text;
     cursor: text;
 
     max-height: 250px;
@@ -573,3 +596,9 @@ body.large .detail .large {
     border: 1px solid hsla(0, 0%, 0%, 0.1);
     padding: 1em;
 }
+
+#load-results-button {
+    margin-left: 1em;
+    min-width: auto;
+    font-size: 0.8em;
+}
diff --git a/MotionMark/resources/runner/motionmark.js b/MotionMark/resources/runner/motionmark.js
index 193e212..1bf8d25 100644
--- a/MotionMark/resources/runner/motionmark.js
+++ b/MotionMark/resources/runner/motionmark.js
@@ -67,6 +67,7 @@ class BenchmarkRunnerClient {
 class SectionsManager {
     showSection(sectionIdentifier, pushState)
     {
+        this.currentSectionIdentifier = sectionIdentifier;
         var sections = document.querySelectorAll("main > section");
         for (var i = 0; i < sections.length; ++i) {
             document.body.classList.remove("showing-" + sections[i].id);
@@ -313,6 +314,15 @@ class BenchmarkController {
         const score = scoreCalculator.score;
         const confidence = "±" + (Statistics.largestDeviationPercentage(scoreCalculator.scoreLowerBound, score, scoreCalculator.scoreUpperBound) * 100).toFixed(2) + "%";
         const fps = scoreCalculator.targetFrameRate;
+
+        const resultsScoreProfileSelector = document.getElementById("results-score-profile");
+        if (resultsScoreProfileSelector)
+            resultsScoreProfileSelector.value = scoreCalculator.scoreProfile;
+
+        const graphScoreProfileSelector = document.getElementById("graph-score-profile");
+        if (graphScoreProfileSelector)
+            graphScoreProfileSelector.value = scoreCalculator.scoreProfile;
+
         sectionsManager.setSectionVersion("results", scoreCalculator.version);
         sectionsManager.setSectionScore("results", score.toFixed(2), confidence, fps);
         sectionsManager.populateTable("results-header", Headers.testName, scoreCalculator);
@@ -321,6 +331,14 @@ class BenchmarkController {
         sectionsManager.showSection("results", true);
     }
 
+    changeScoreProfile(profile) {
+        this.runnerClient.scoreCalculator.recompute(profile);
+        if (sectionsManager.currentSectionIdentifier == "test-graph" && this.reloadCurrentGraph)
+            this.reloadCurrentGraph();
+        else
+            this.showResults();
+    }
+
     handleKeyPress(event)
     {
         switch (event.charCode)
@@ -331,6 +349,9 @@ class BenchmarkController {
         case 106: // j
             benchmarkController.showDebugInfo();
             break;
+        case 100: // d
+            benchmarkController.downloadDebugInfo();
+            break;
         case 115: // s
             benchmarkController.selectResults(event.target);
             break;
@@ -380,11 +401,39 @@ class BenchmarkController {
             selection.addRange(range);
         };
 
-        var button = Utilities.createElement("button", {}, container);
-        button.textContent = "Done";
-        button.onclick = () => {
+        var doneButton = Utilities.createElement("button", {}, container);
+        doneButton.textContent = "Done";
+        doneButton.onclick = () => {
             this.hideDebugInfo();
         };
+
+        var downloadButton = Utilities.createElement("button", {}, container);
+        downloadButton.textContent = "Download";
+        downloadButton.onclick = () => {
+            this.downloadDebugInfo();
+        };
+    }
+
+    downloadDebugInfo()
+    {
+        var output = {
+            version: this.runnerClient.scoreCalculator.version,
+            options: this.runnerClient.scoreCalculator.options,
+            data: this.runnerClient.scoreCalculator.data
+        };
+        var json = JSON.stringify(output, (key, value) => {
+            if (typeof value === 'number')
+                return Utilities.toFixedNumber(value, 3);
+            return value;
+        }, 1);
+        var blob = new Blob([json], { type: "application/json" });
+        var url = URL.createObjectURL(blob);
+
+        var a = document.createElement('a');
+        a.href = url;
+        a.download = 'motionmark-results.json';
+        a.click();
+        URL.revokeObjectURL(url);
     }
 
     selectResults(target)
diff --git a/MotionMark/resources/runner/results.js b/MotionMark/resources/runner/results.js
index 291992a..2b47eea 100644
--- a/MotionMark/resources/runner/results.js
+++ b/MotionMark/resources/runner/results.js
@@ -108,6 +108,15 @@ class ScoreCalculator {
         this._runData.runs.push(suitesSamplers);
     }
 
+    recompute(profile) {
+        this._preferredProfile = profile;
+        this._processData();
+    }
+
+    get scoreProfile() {
+        return this._preferredProfile || "slope";
+    }
+
     _processData()
     {
         this._results = {};
@@ -132,11 +141,9 @@ class ScoreCalculator {
                 suitesResult[suiteName] = suiteResult;
 
                 for (var testName in suiteData) {
-                    if (!suiteData[testName][Strings.json.result])
-                        this.calculateScore(suiteData[testName]);
+                    this.calculateScore(suiteData[testName]);
 
                     suiteResult[testName] = suiteData[testName][Strings.json.result];
-                    delete suiteData[testName][Strings.json.result];
 
                     testsScores.push(suiteResult[testName][Strings.json.score]);
                     testsLowerBoundScores.push(suiteResult[testName][Strings.json.scoreLowerBound]);
@@ -168,8 +175,8 @@ class ScoreCalculator {
         function findRegression(series, profile) {
             const minIndex = Math.round(.025 * series.length);
             const maxIndex = Math.round(.975 * (series.length - 1));
-            const minComplexity = series.getFieldInDatum(minIndex, complexityKey);
-            const maxComplexity = series.getFieldInDatum(maxIndex, complexityKey);
+            let minComplexity = series.getFieldInDatum(minIndex, complexityKey);
+            let maxComplexity = series.getFieldInDatum(maxIndex, complexityKey);
 
             if (Math.abs(maxComplexity - minComplexity) < 20 && maxIndex - minIndex < 20) {
                 minIndex = 0;
@@ -180,6 +187,7 @@ class ScoreCalculator {
 
             const frameTypeIndex = series.fieldMap[Strings.json.frameType];
             const complexityIndex = series.fieldMap[complexityKey];
+            const frameTimeIndex = series.fieldMap[Strings.json.time];
             const frameLengthIndex = series.fieldMap[Strings.json.frameLength];
             const regressionOptions = { desiredFrameLength: desiredFrameLength };
             if (profile)
@@ -187,7 +195,7 @@ class ScoreCalculator {
 
             const regressionSamples = series.slice(minIndex, maxIndex + 1);
             const animationSamples = regressionSamples.data.filter((sample) => sample[frameTypeIndex] == Strings.json.animationFrameType);
-            const regressionData = animationSamples.map((sample) => [ sample[complexityIndex], sample[frameLengthIndex] ]);
+            const regressionData = animationSamples.map((sample) => [ sample[complexityIndex], sample[frameLengthIndex], sample[frameTimeIndex] ]);
 
             const regression = new Regression(regressionData, minIndex, maxIndex, regressionOptions);
             return {
@@ -206,24 +214,30 @@ class ScoreCalculator {
         });
 
         const isRampController = this._runData.options[Strings.json.controller] == "ramp";
-        let predominantProfile = "";
+        let predominantProfile = this._preferredProfile || "";
         if (isRampController) {
-            var profiles = {};
-            data[Strings.json.controller].forEach(function(regression) {
-                if (regression[Strings.json.regressions.profile]) {
-                    var profile = regression[Strings.json.regressions.profile];
-                    profiles[profile] = (profiles[profile] || 0) + 1;
-                }
-            });
+            if (!predominantProfile) {
+                var profiles = {};
+                data[Strings.json.controller].forEach(function (regression) {
+                    if (regression[Strings.json.regressions.profile]) {
+                        var profile = regression[Strings.json.regressions.profile];
+                        profiles[profile] = (profiles[profile] || 0) + 1;
+                    }
+                });
 
-            var maxProfileCount = 0;
-            for (var profile in profiles) {
-                if (profiles[profile] > maxProfileCount) {
-                    predominantProfile = profile;
-                    maxProfileCount = profiles[profile];
+                var maxProfileCount = 0;
+                for (var profile in profiles) {
+                    if (profiles[profile] > maxProfileCount) {
+                        predominantProfile = profile;
+                        maxProfileCount = profiles[profile];
+                    }
                 }
             }
+            data[Strings.json.controller].forEach(function (regression) {
+                regression[Strings.json.regressions.profile] = predominantProfile;
+            });
         }
+        this._preferredProfile = predominantProfile;
 
         const regressionResult = findRegression(samples[complexityKey], predominantProfile);
         const calculation = regressionResult.regression;
diff --git a/MotionMark/resources/statistics.js b/MotionMark/resources/statistics.js
index bd0d7e3..d8e76ee 100644
--- a/MotionMark/resources/statistics.js
+++ b/MotionMark/resources/statistics.js
@@ -178,8 +178,10 @@ class Regression {
     constructor(samples, startIndex, endIndex, options)
     {
         const desiredFrameLength = options.desiredFrameLength;
-        var profile;
+        const kWindowSizeMultiple = 0.1;
 
+        var profile;
+            
         if (!options.preferredProfile || options.preferredProfile == Strings.json.profiles.slope) {
             profile = this._calculateRegression(samples, {
                 shouldClip: true,
@@ -195,6 +197,11 @@ class Regression {
                 t2: 0
             });
             this.profile = Strings.json.profiles.flat;
+        } else if (options.preferredProfile == Strings.json.profiles.window || options.preferredProfile == Strings.json.profiles.windowStrict) {
+            const window_size = Math.max(1, Math.floor(samples.length * kWindowSizeMultiple));
+            const strict = options.preferredProfile == Strings.json.profiles.windowStrict;
+            profile = this._windowedFit(samples, desiredFrameLength, window_size, strict);
+            this.profile = options.preferredProfile;
         }
 
         this.startIndex = Math.min(startIndex, endIndex);
@@ -219,6 +226,111 @@ class Regression {
         return this.s1 + this.t1 * complexity;
     }
 
+    _windowedFit(samples, desiredFrameLength, windowSize, strict)
+    {
+        const kAllowedErrorFactor = 0.9;
+
+        const complexityIndex = 0;
+        const frameLengthIndex = 1;
+        const frameTimeIndex = 2;
+
+        const average = array => array.reduce((a, b) => a + b) / array.length;
+
+        var sortedSamples = samples.slice().sort((a, b) => {
+                if (a[complexityIndex] == b[complexityIndex])
+                    return b[frameTimeIndex] - a[frameTimeIndex];
+                return a[complexityIndex] - b[complexityIndex];
+            });
+
+        var cumFrameLength = 0.0;
+        var bestIndex = 0;
+        var bestComplexity = 0;
+        var runningFrameLengths = [];
+        var runningComplexities = [];
+
+        for (var i = 0; i < sortedSamples.length; ++i) {
+            runningFrameLengths.push(sortedSamples[i][frameLengthIndex]);
+            runningComplexities.push(sortedSamples[i][complexityIndex]);
+
+            if (runningFrameLengths.length < windowSize) {
+                continue
+            } else if (runningFrameLengths.length > windowSize) {
+                runningFrameLengths.shift();
+                runningComplexities.shift();
+            }
+
+            let averageFrameLength = average(runningFrameLengths);
+            let averageComplexity = average(runningComplexities);
+            let error = desiredFrameLength / averageFrameLength;
+            let adjustedComplexity = averageComplexity * Math.min(1.0, error);
+
+            if (error >= kAllowedErrorFactor) {
+                if (adjustedComplexity > bestComplexity) {
+                    bestComplexity = adjustedComplexity;
+                }
+            } else if (strict) {
+                break;
+            }
+        }
+
+        for (var i = 0; i < sortedSamples.length; ++i) {
+            if (sortedSamples[i][complexityIndex] <= bestComplexity)
+                bestIndex = i;
+        }
+
+        let complexity = bestComplexity;
+
+        // Calculate slope for remaining points
+        let t_nom = 0.0;
+        let t_denom = 0.0;
+        for (var i = bestIndex + 1; i < sortedSamples.length; i++) {
+            const tx = sortedSamples[i][complexityIndex] - complexity;
+            const ty = sortedSamples[i][frameLengthIndex] - desiredFrameLength;
+            t_nom += tx * ty;
+            t_denom += tx * tx;
+        }
+
+        var s1 = desiredFrameLength;
+        var t1 = 0;
+        var t2 = (t_nom / t_denom) || 0.0;
+        var s2 = desiredFrameLength - t2 * complexity;
+        var n1 = bestIndex + 1;
+        var n2 = sortedSamples.length - bestIndex - 1;
+
+        function getValueAt(at_complexity)
+        {
+            if (at_complexity > complexity)
+                return s2 + t2 * complexity;
+            return s1 + t1 * complexity;
+        }
+
+        let error1 = 0.0;
+        let error2 = 0.0;
+        for (var i = 0; i < n1; ++i) {
+            const frameLengthErr = sortedSamples[i][frameLengthIndex] - getValueAt(sortedSamples[i][complexityIndex]);
+            error1 += frameLengthErr * frameLengthErr;
+        }
+        for (var i = n1; i < sortedSamples.length; ++i) {
+            const frameLengthErr = sortedSamples[i][frameLengthIndex] - getValueAt(sortedSamples[i][complexityIndex]);
+            error2 += frameLengthErr * frameLengthErr;
+        }
+        
+        return {
+            s1: s1,
+            t1: t1,
+            s2: s2,
+            t2: t2,
+            complexity: complexity,
+            // Number of samples included in the first segment, inclusive of bestIndex
+            n1: n1,
+            // Number of samples included in the second segment
+            n2: n2,
+            stdev1: Math.sqrt(error1 / n1),
+            stdev2: Math.sqrt(error2 / n2),
+            error: error1 + error2,
+        };        
+    }
+
     // A generic two-segment piecewise regression calculator. Based on Kundu/Ubhaya
     //
     // Minimize sum of (y - y')^2
diff --git a/MotionMark/resources/strings.js b/MotionMark/resources/strings.js
index 43e0510..735e901 100644
--- a/MotionMark/resources/strings.js
+++ b/MotionMark/resources/strings.js
@@ -78,7 +78,9 @@ var Strings = {
 
         profiles: {
             slope: "slope",
-            flat: "flat"
+            flat: "flat",
+            window: "window",
+            windowStrict: "window-strict",
         },
 
         results: {
diff --git a/MotionMark/tests/resources/controllers.js b/MotionMark/tests/resources/controllers.js
index 33d5476..513ce48 100644
--- a/MotionMark/tests/resources/controllers.js
+++ b/MotionMark/tests/resources/controllers.js
@@ -170,10 +170,15 @@ class Controller {
     {
         return samples[sampleTimeIndex][i] - samples[sampleTimeIndex][i - 1];
     }
+
+    _getFrameTime(samples, i)
+    {
+        return samples[sampleTimeIndex][i];
+    }
     
     _previousFrameComplexity(samples, i)
     {
-        if (i > 0)
+        if (i > 1)
             return this._getComplexity(samples, i - 1);
 
         return 0;
@@ -415,6 +420,7 @@ class RampController extends Controller {
         super(benchmark, options);
         
         this.targetFPS = targetFPS;
+        this.preferredProfile = options["score-profile"];
 
         // Initially start with a tier test to find the bounds
         // The number of objects in a tier test is 10^|_tier|
@@ -505,6 +511,11 @@ class RampController extends Controller {
                 var nextTierComplexity = Math.max(Math.round(Math.pow(10, this._tier)), currentComplexity + 1);
                 stage.tune(nextTierComplexity - currentComplexity);
 
+                // If the next tier complexity couldn't be set, we've reached the maximum capacity for the test
+                if (stage.complexity() != nextTierComplexity) {
+                   this._maximumStageComplexity = stage.complexity();
+                }
+
                 // Some tests may be unable to go beyond a certain capacity. If so, don't keep moving up tiers
                 if (stage.complexity() - currentComplexity > 0 || nextTierComplexity == 1) {
                     this._tierStartTimestamp = timestamp;
@@ -536,6 +547,12 @@ class RampController extends Controller {
                 // If the browser is capable of handling the most complex version of the test, use that
                 this._maximumComplexity = currentComplexity;
             }
+
+            if (this._maximumStageComplexity) {
+                // If we reached the maximum stage complexity, set the maximum such
+                // that the stage complexity is in the middle of the ramp.
+                this._maximumComplexity = Math.round(this._maximumStageComplexity * 1.25);
+            }
             
             this._possibleMaximumComplexity = this._maximumComplexity;
 
@@ -602,10 +619,15 @@ class RampController extends Controller {
         for (var i = this._rampStartIndex; i < this._sampler.sampleCount; ++i) {
             if (this._getFrameType(this._sampler.samples, i) == Strings.json.mutationFrameType)
                 continue;
-            regressionData.push([ this._getComplexity(this._sampler.samples, i), this._getFrameLength(this._sampler.samples, i) ]);
+            regressionData.push(
+                [
+                    this._getComplexity(this._sampler.samples, i), 
+                    this._getFrameLength(this._sampler.samples, i),
+                    this._getFrameTime(this._sampler.samples, i)
+                ]);
         }
 
-        var regression = new Regression(regressionData, this._sampler.sampleCount - 1, this._rampStartIndex, { desiredFrameLength: this.frameLengthDesired });
+        var regression = new Regression(regressionData, this._sampler.sampleCount - 1, this._rampStartIndex, { desiredFrameLength: this.frameLengthDesired, preferredProfile: this.preferredProfile });
         this._rampRegressions.push(regression);
 
         var frameLengthAtMaxComplexity = regression.valueAt(this._maximumComplexity);
@@ -632,6 +654,12 @@ class RampController extends Controller {
             this._maximumComplexity = Math.max(Math.round(.8 * this._maximumComplexity), this._minimumComplexity + 5);
         }
 
+        if (this._maximumStageComplexity) {
+            // If we reached the maximum stage complexity, set the maximum such
+            // that the stage complexity is in the middle of the ramp.
+            this._maximumComplexity = Math.min(Math.round(this._maximumStageComplexity * 1.25), this._maximumComplexity);
+        }
+
         // Next ramp
         stage.tune(this._maximumComplexity - stage.complexity());
         this._rampDidWarmup = false;