diff --git a/src/parser/__tests__/ArcanistBundleTestCase.php b/src/parser/__tests__/ArcanistBundleTestCase.php
index 6dc2a0a0..19f251d9 100644
--- a/src/parser/__tests__/ArcanistBundleTestCase.php
+++ b/src/parser/__tests__/ArcanistBundleTestCase.php
@@ -1,910 +1,912 @@
 <?php
 
 final class ArcanistBundleTestCase extends ArcanistTestCase {
 
   private function loadResource($name) {
     return Filesystem::readFile($this->getResourcePath($name));
   }
 
   private function getResourcePath($name) {
     return dirname(__FILE__).'/bundle/'.$name;
   }
 
   private function loadDiff($old, $new) {
     list($err, $stdout) = exec_manual(
       'diff --unified=65535 --label %s --label %s -- %s %s',
       'file 9999-99-99',
       'file 9999-99-99',
       $this->getResourcePath($old),
       $this->getResourcePath($new));
     $this->assertEqual(
       1,
       $err,
       "Expect `diff` to find changes between '{$old}' and '{$new}'.");
     return $stdout;
   }
 
   private function loadOneChangeBundle($old, $new) {
     $diff = $this->loadDiff($old, $new);
     return ArcanistBundle::newFromDiff($diff);
   }
 
   /**
    * Unarchive a saved git repository and apply each commit as though via
    * "arc patch", verifying that the resulting tree hash is identical to the
    * tree hash produced by the real commit.
    */
   public function testGitRepository() {
     if (phutil_is_windows()) {
       $this->assertSkipped('This test is not supported under Windows.');
     }
 
     $archive = dirname(__FILE__).'/bundle.git.tgz';
     $fixture = PhutilDirectoryFixture::newFromArchive($archive);
 
     $old_dir = getcwd();
     chdir($fixture->getPath());
 
     $caught = null;
     try {
       $this->runGitRepositoryTests($fixture);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     chdir($old_dir);
 
     if ($caught) {
       throw $ex;
     }
   }
 
   private function runGitRepositoryTests(PhutilDirectoryFixture $fixture) {
     $patches = dirname(__FILE__).'/patches/';
 
     list($commits) = execx(
       'git log --format=%s',
       '%H %T %s');
     $commits = explode("\n", trim($commits));
 
     // The very first commit doesn't have a meaningful parent, so don't examine
     // it.
     array_pop($commits);
 
     foreach ($commits as $commit) {
       list($commit_hash, $tree_hash, $subject) = explode(' ', $commit, 3);
       execx('git reset --hard %s --', $commit_hash);
 
       $fixture_path = $fixture->getPath();
       $working_copy = ArcanistWorkingCopyIdentity::newFromPath($fixture_path);
 
       $configuration_manager = new ArcanistConfigurationManager();
       $configuration_manager->setWorkingCopyIdentity($working_copy);
       $repository_api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
         $configuration_manager);
 
       $repository_api->setBaseCommitArgumentRules('arc:this');
-      $diff = $repository_api->getFullGitDiff();
+      $diff = $repository_api->getFullGitDiff(
+        $repository_api->getBaseCommit(),
+        $repository_api->getHeadCommit());
 
       $parser = new ArcanistDiffParser();
       $parser->setRepositoryAPI($repository_api);
       $changes = $parser->parseDiff($diff);
 
       $this->makeChangeAssertions($commit_hash, $changes);
 
       $bundle = ArcanistBundle::newFromChanges($changes);
 
       execx('git reset --hard %s^ --', $commit_hash);
 
       $patch = $bundle->toGitPatch();
 
       $expect_path = $patches.'/'.$commit_hash.'.gitpatch';
       $expect = null;
       if (Filesystem::pathExists($expect_path)) {
         $expect = Filesystem::readFile($expect_path);
       }
 
       if ($patch === $expect) {
         $this->assertEqual($expect, $patch);
       } else {
         Filesystem::writeFile($expect_path.'.real', $patch);
         throw new Exception(
           "Expected patch and actual patch for {$commit_hash} differ. ".
           "Wrote actual patch to '{$expect_path}.real'.");
       }
 
       try {
         id(new ExecFuture('git apply --index --reject'))
           ->write($patch)
           ->resolvex();
       } catch (CommandException $ex) {
         $temp = new TempFile(substr($commit_hash, 0, 8).'.patch');
         $temp->setPreserveFile(true);
         Filesystem::writeFile($temp, $patch);
 
         PhutilConsole::getConsole()->writeErr(
           "Wrote failing patch to '%s'.\n",
           $temp);
         throw $ex;
       }
 
       execx('git commit -m %s', $subject);
       list($result_hash) = execx('git log -n1 --format=%s', '%T');
       $result_hash = trim($result_hash);
 
       $this->assertEqual(
         $tree_hash,
         $result_hash,
         "Commit {$commit_hash}: {$subject}");
     }
   }
 
   private function makeChangeAssertions($commit, array $raw_changes) {
     $changes = array();
 
     // Verify that there are no duplicate changes, and rekey the changes on
     // affected path because we don't care about the order in which the
     // changes appear.
     foreach ($raw_changes as $change) {
       $this->assertTrue(
         empty($changes[$change->getCurrentPath()]),
         'Unique Path: '.$change->getCurrentPath());
       $changes[$change->getCurrentPath()] = $change;
     }
 
     switch ($commit) {
       case '1830a13adf764b55743f7edc6066451898d8ffa4':
         // "Mark koan2 as +x and edit it."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case '8ecc728bcc9b482a9a91527ea471b04fc1a025cf':
         // "Move 'text' to 'executable' and mark it +x."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['executable'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case '39c8e7dd3914edff087a6214f0cd996ad08e5b3d':
         // "Mark koan as +x."
         // Primarily a test against a recusive synthetic hunk construction bug.
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case 'c573c25d1a767d270fed504cd993e78aba936338':
         // "Copy a koan over text, editing the original koan."
         // Git doesn't really do anything meaningful with this.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $c = $changes['text'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         break;
       case 'd26628e588cf7d16368845b121c6ac6c781e81d0':
         // "Copy a koan, modifying both the source and destination."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $c->getType());
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
 
         break;
       case 'b0c9663ecda5f666f62dad245a3a7549aac5e636':
         // "Remove a koan copy."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         break;
       case 'b6ecdb3b4801f3028d88ba49940a558360847dbf':
         // "Copy a koan and edit the destination."
         // Git does not detect this as a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '30d23787e1ecd254c884afbe37afa612f61e3904':
         // "Move and edit a koan."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case 'c0ba9bfe3695f95c3f558bc5797eeba421d32483':
         // "Remove two koans."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan3'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         $c = $changes['koan4'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         break;
       case '2658fd01d5355abe5d4c7ead3a0e7b4b3449fe77':
         // "Multicopy a koan."
 
         $this->assertEqual(3, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MULTICOPY,
           $c->getType());
 
         $c = $changes['koan3'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
 
         $c = $changes['koan4'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case '1c5fe4e2243bb19d6b3bf15896177b13768e6eb6':
         // "Copy a koan."
         // Git does not detect this as a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '6d9eb65a2c2b56dee64d72f59554c1cca748dd34':
         // "Move a koan."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case '141452e2a775ee86409e8779dd2eda767b4fe8ab':
         // "Add a koan."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '5dec8bf28557f078d1987c4e8cfb53d08310f522':
         // "Copy an image, and replace the original."
         // `image_2.png` is copied to `image.png` and then replaced.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           'c9ec1b952480da09b393ba672d9b13da',
           md5($c->getCurrentFileData()));
 
         break;
       case 'fb28468d25a5fdd063aca4ca559454c998a0af51':
         // "Multicopy image."
         // `image.png` is copied to `image_2.png` and `image_3.png` and then
         // deleted. Git detects this as a move and an add.
 
         $this->assertEqual(3, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MULTICOPY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         $c = $changes['image_3.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case 'df340e88d8aba12e8f2b8827f01f0cd9f35eb758':
         // "Remove binary image."
         // `image_2.png` is deleted.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         break;
       case '3f5c6d735e64c25a04f83be48ef184b25b5282f0':
         // "Copy binary image."
         // `image_2.png` is copied to `image.png`. Git does not detect this as
         // a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case 'b454edb3bb29890ee5b3af5ef66ce6a24d15d882':
         // "Move binary image."
         // `image.png` is moved to `image_2.png`.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case '5de5f3dfda1b7db2eb054e57699f05aaf1f4483e':
         // "Add a binary image."
         // `image.png` is added.
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case '176a4c2c3fd88b2d598ce41a55d9c3958be9fd2d':
         // "Convert \r\n newlines to \n newlines."
       case 'a73b28e139296d23ade768f2346038318b331f94':
         // "Add text with \r\n newlines."
       case '337ccec314075a2bdb4a912ef467d35d04a713e4':
         // "Convert \n newlines to \r\n newlines.";
       case '6d5e64a4a7a6a036c53b1d087184cb2c70099f2c':
         // "Remove tabs."
       case '49395994a1a8a06287e40a3b318be4349e8e0288':
         // "Add tabs."
       case 'a5a53c424f3c2a7e85f6aee35e834c8ec5b3dbe3':
         // "Add trailing newline."
       case 'd53dc614090c6c7d6d023e170877d7f611f18f5a':
         // "Remove trailing newline."
       case 'f19fb9fa1385c01b53bdb6d8842dd154e47151ec':
         // "Edit a text file."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['text'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_TEXT,
           $c->getFileType());
         break;
       case '228d7be4840313ed805c25c15bba0f7b188af3e6':
         // "Add a text file."
         // This commit is never reached because we skip the 0th commit junk.
         $this->assertTrue(true, 'This is never reached.');
         break;
       default:
         throw new Exception(
           "Commit {$commit} has no change assertions!");
     }
   }
 
   public function testTrailingContext() {
     // Diffs need to generate without extra trailing context, or 'patch' will
     // choke on them.
     $this->assertEqual(
       $this->loadResource('trailing-context.diff'),
       $this->loadOneChangeBundle(
         'trailing-context.old',
         'trailing-context.new')->toUnifiedDiff());
   }
 
   public function testDisjointHunks() {
     // Diffs need to generate without overlapping hunks.
     $this->assertEqual(
       $this->loadResource('disjoint-hunks.diff'),
       $this->loadOneChangeBundle(
         'disjoint-hunks.old',
         'disjoint-hunks.new')->toUnifiedDiff());
   }
 
   public function testNonlocalTrailingNewline() {
     // Diffs without changes near the end of the file should not generate a
     // bogus, change-free hunk if the file has no trailing newline.
     $this->assertEqual(
       $this->loadResource('trailing-newline.diff'),
       $this->loadOneChangeBundle(
         'trailing-newline.old',
         'trailing-newline.new')->toUnifiedDiff());
   }
 
   public function testEncodeBase85() {
 
     $data = '';
     for ($ii = 0; $ii <= 255; $ii++) {
       $data .= chr($ii);
     }
     for ($ii = 255; $ii >= 0; $ii--) {
       $data .= chr($ii);
     }
 
     $expect = Filesystem::readFile(dirname(__FILE__).'/base85/expect1.txt');
     $expect = trim($expect);
 
     $this->assertEqual(
       $expect,
       ArcanistBundle::encodeBase85($data));
 
     // This is just a large block of random binary data, it has no special
     // significance.
 
     $data =
       "\x56\x4c\xb3\x63\xe5\x4a\x9f\x03\xa3\x4c\xdd\x5d\x85\x86\x10".
       "\x30\x3f\xc1\x28\x51\xd8\xb2\x1a\xc3\x79\x15\x85\x31\x66\xf9".
       "\x8e\xe1\x20\x8f\x12\xa1\x94\x0e\xbf\xb6\x9c\xb5\xc0\x15\x43".
       "\x3d\xad\xed\x00\x3c\x16\xfa\x76\x2f\xed\x99\x3a\x78\x3e\xd1".
       "\x91\xf8\xb0\xca\xb9\x29\xfe\xd4\x0f\x16\x70\x19\xad\xd9\x42".
       "\x15\xb4\x8f\xd6\x8f\x80\x62\xe9\x48\x77\x9f\x38\x6d\x3f\xd6".
       "\x0e\x40\x68\x68\x93\xae\x75\x6d\x7f\x75\x9c\x80\x69\x94\x22".
       "\x87\xb6\xc0\x62\x6b\xab\x49\xb8\x91\xe9\x96\xbf\x04\xc2\x50".
       "\x30\xae\xea\xc1\x70\x8e\x91\xd0\xb6\xec\x56\x14\x78\xd5\x8a".
       "\x8c\x52\xd1\x3c\xde\x65\x21\xec\x93\xab\xcf\x7e\xf5\xfd\x6d".
       "\x2d\x69\xb9\x2e\xa3\x42\x7b\x4d\xa5\xfb\x28\x6d\x74\xa3\x7b".
       "\x3a\xc5\x34\x7c\x63\xa9\xf9\x8e\x34\x14\x42\xb0\xf1\x0e\xe2".
       "\xd0\xd2\x04\x81\xff\x62\xd5\xd9\x46\x3b\x36\x88\x8a\x93\x55".
       "\x02\x2c\xff\x9f\x48\xd6\x7a\xcb\xbf\x6a\x33\xaa\x6b\x08\x4c".
       "\x96\x98\x89\x53\x56\xb4\xb3\x9b\x06\xb1\xa0\x13\x69\xfa\x6a".
       "\xa8\x0d\x6a\xda\xb2\x6f\x62\x0b\xa8\xf6\x59\x29\x46\x7d\x04".
       "\x44\xeb\x90\x6f\xd7\xc7\xb6\xca\xc5\xeb\xde\x10\x9b\xbd\xf2".
       "\x66\x8e\xd0\x0b\xda\x8c\xeb\x90\x73\x73\x33\xe7\x6f\x26\x57".
       "\x4e\xfc\x95\xe0\xfc\x62\x93\xa7\x28\xe6\x0c\x46\x73\xdd\x01".
       "\xce\x43\x9b\x4e\x16\x74\x5b\x36\x92\x5a\x66\x4c\xe3\x9e\x90".
       "\x2d\x9a\x1a\x3d\x69\x39\x67\x04\xd6\xf8\x5f\x45\xee\xbb\xd4".
       "\x63\xcf\x8c\x9b\x31\x69\x98\x1a\x98\x57\x4b\xa9\x49\xf6\x1b".
       "\x76\x28\xd7\xe3\x8f\x63\x95\x5b\x06\xe2\xa8\x66\x60\xf9\x49".
       "\x4e\x40\x53\x32\x9b\x74\x36\xc0\x56\xf4\x33\xec\x83\xd2\x2c".
       "\x69\x60\x55\x11\x3b\x4f\xd6\x0a\xf6\x04\x38\x75\xb6\xc2\x82".
       "\x4d\xfa\x83\x56\xba\x35\x42\xc3\xcb\xdc\x28\xf4\x69\x48\xa9".
       "\xe0\x51\x41\x79\x66\xfe\x61\xd1\xf2\x9f\x7b\xde\xc4\x3e\x8f".
       "\x8f\xb6\x9c\x0a\x74\xf8\x71\x03\x37\x37\x30\x8d\x2a\x6a\xc9".
       "\x51\xa1\xe2\x34\xe5\x42\xdb\x4f\x61\x4e\x16\xfc\x23\x72\x12".
       "\x46\x53\x12\x82\x3e\x44\x63\x23\x82\xaa\xab\x7e\x8d\x70\x66".
       "\xf1\x94\x86\x02\xc5\x3e\x9c\x79\x17\x1e\x9f\x13\x89\x3d\x25".
       "\x45\xc9\x3b\x1e\xa0\x1a\x03\x20\x1c\x81\x6b\xfc\xb5\xc9\xe2".
       "\xda\xb1\x87\x34\xa0\xb2\x72\x36\x68\x12\x05\x53\x7c\x68\x6b".
       "\x1e\x2a\x56\x2a\x7e\x7f\xd0\x9c\x13\xa9\xb2\x4c\xe6\x8a\x65".
       "\xd7\x67\xad\xf3\xf3\x2b\x9c\xe8\x10\x07\x8a\xe2\x20\x67\xe4".
       "\x51\x47\xc1\x22\x91\x05\x22\x39\x1a\xef\x54\xd2\x8a\x88\x55".
       "\x3f\x83\xba\x73\xd4\x95\xc7\xb8\xa2\xfd\x4d\x4e\x5d\xff\xdd".
       "\xaf\x1a\xc2\x7e\xb5\xfa\x86\x5f\x93\x38\x5d\xca\x9a\x5a\x7e".
       "\xb7\x47\xd5\x5c\x6b\xf3\x32\x03\x11\x44\xe9\x49\x12\x40\x82".
       "\x67\x7d\x2a\x5a\x61\x81\xbd\x24\xaa\xd7\x7c\xc9\xcf\xaf\xb0".
       "\x3e\xb0\x43\xcd\xce\x21\xe4\x1b\x5a\xd6\x40\xf5\x0e\x23\xef".
       "\x70\xf4\xc6\xd2\xd7\x36\xd7\x20\xda\x8d\x39\x46\xea\xfc\x78".
       "\x55\xa2\x02\xd6\x77\x21\xc8\x97\x1e\xdf\x45\xde\x93\xa7\x74".
       "\xd8\x59\x10\x24\x8a\xe8\xcd\xe9\x00\xb5\x4e\xe6\x49\xb0\xde".
       "\x14\x1a\x5d\xdd\x38\x47\xb0\xc7\x1e\xec\x7c\x76\xc9\x21\x3c".
       "\x3a\x85\x4f\x71\x97\xed\x4a\x94\x2c\x51\x48\x9c\x43\x90\x70".
       "\xe9\x0e\x84\x55\xd2\xa4\x48\xfa\xfd\x54\x12\x11\xb9\x32\xfc".
       "\x1d\x66\xe7\x42\xe3\x5e\x65\xf4\x3d\xea\x1a\x53\xe3\x7b\x4b".
       "\xee\xdb\x74\xce\x30\xd3\x04\xcb\xda\xa4\xdd\xad\x98\x3a\x76".
       "\xe8\xba\x1b\x03\x53\xed\x46\x5d\xef\xd4\x34\xc2\x8d\xef\xae".
       "\x51\x35\x0f\x4d\x40\xaa\x3a\xdb\x50\x1a\xbe\x5f\x8b\xb8\x24".
       "\x40\x19\x8f\x8a\x6b\x44\x4f\x9b\xe0\xf4\x9c\x4b\xc4\x23\x37".
       "\xf0\xb3\xe1\x58\x9d\x0e\xd9\xa9\xf7\x3e\x86\x43\x9b\x5b\x90".
       "\x3c\xc0\x20\xa0\xc5\x86\x4f\xc6\xcb\xb5\xcb\xd4\x88\xc6\x72".
       "\x57\xa7\x57\x2c\x34\x26\x91\x44\x15\xa8\xf4\x88\xca\x74\x56".
       "\x9e\x12\x6c\xdf\x52\xef\xc0\xb4\x5c\x16\xe8\xaa\xf7\xb6\xf3".
       "\x7c\xda\xcd\x42\xf9\x1c\x40\x88\x44\x68\x4f\x1b\x5a\x7b\x8f".
       "\xc3\x47\x48\xd3\xf3\xe5\xf5\x66\x35\x48\xbe\x64\xdf\xfe\x35".
       "\xf1\xc3\xe4\xa8\xfc\x86\xfb\x69\x20\xc9\xf4\x16\x96\xc1\x7a".
       "\x51\x14\x77\xa4\x6e\x13\xe8\x59\x35\x24\xf1\xe5\xfe\xe9\x98".
       "\x0d\xd1\xe8\xce\x9c\x7f\xf8\x3b\x79\x39\x3a\x1d\xa3\x77\xef".
       "\x4f\x4b\x59\x73\x03\xb3\xfe\xae\x70\x2a\x3a\xf0\x79\x9d\x7e".
       "\x9b\xaa\xb1\x18\xf9\x43\x69\xf3\x55\x46\xad\x38\xa2\xf1\xcb".
       "\xce\x37\xa9\x88\x20\x38\xea\x19\x29\x95\x8c\x75\x06\x9d\x1d".
       "\x9e\xf2\xb7\x64\x98\x21\x36\x90\x92\xf8\xb8\x89\x1e\x5c\x5d".
       "\x09\x3b\x52\xc5\x6a\x87\x7e\x46\xca\x8c\xdf\xe7\xca\xa9\x7b".
       "\x11\x63\x0f\x9e\x42\x9a\x3e\xe0\x8b\x80\x9e\x91\x76\x88\x9a".
       "\xa1\xe2\x96\xae\xfb\x18\x39\xdc\x92\x99\x34\xfd\x98\x20\xa8".
       "\x89\x61\x2c\x26\xe0\xb8\x83\xa7\xe7\x50\x42\x8f\xfc\x36\x66".
       "\x6b\x25\xc5\x6d\xb4\x31\xe1\x4d\x0f\x2e\xf8\x44\xe2\xb6\x6a".
       "\x6d\xfe\x83\x9e\x2c\x07\x2f\x15\x41\xf3\xe7\xa6\x18\x2b\x84".
       "\x7e\xeb\x43\xcc\xbb\xdb\xa9\x54\x5c\xbc\x59\x6a\xdc\x26\x2a".
       "\xf4\x59\xa7\x75\xa4\xac\xed\x73\x8f\x16\x43\x0d\x97\x10\x2c".
       "\x70\xef\x9e\xb2\xc9\xdf\xe6\xa7\x9b\x08\x79\xa3\xf7\x99\xf5".
       "\x59\xe4\xd5\x89\x10\xe5\xc9\xf7\xe7\x29\x72\x06\xc6\x54\xc3".
       "\xcd\xd0\xff\x69\xf8\xdf\x19\xf2\x66\x1c\x69\x40\xbc\x97\xf1".
       "\x49\x5e\x78\x62\x52\x46\x7f\xcf\x44\x50\x8b\x5f\xe7\xa8\xeb".
       "\xd5\x84\x24\x81\xc0\x2c\x65\xf7\x95\xbd\xf2\x8e\x43\xfb\x6a".
       "\x49\x3c\x6a\xe5\x2a\x39\xf0\xfa\x89\x59\x5f\x39\x75\xb4\x6f".
       "\x04\xf1\xe0\x2c\xcd\x77\x34\xec\x6b\x45\x16\xe3\x18\x24\x05".
       "\xb9\x68\xc1\x4e\x71\x4b\xff\x88\x18\xea\x0d\x56\x49\x55\xdf".
       "\xe5\xb0\x59\xdb\x74\x9e\x0b\x38\x03\x9f\x10\x6f\xd9\x34\x07".
       "\x44\x29\x08\xb1\xd4\x77\xc6\x84\x0d\xbb\xb5\xd5\x09\x05\x19".
       "\x01\x62\x29\x45\x52\x1d\xc6\x4f\x25\x78\x7e\xbc\xae\x07\xb3".
       "\xd4\xe0\x19\x91\x03\xd6\x8d\x2f\x00\xc9\xb2\x66\x3b\x4e\x3d".
       "\x75\xf7\x23\x9a\x3e\xa4\xd5\x7f\x75\x47\xd0\xbc\xc3\xc8\x2a".
       "\xdc\x85\x09\x6c\x0c\x90\x38\xd8\xef\xcf\xf4\x7a\x1b\xc7\x76".
       "\xe0\xdb\x81\xa8\x1b\x2b\x8d\xd4\x36\x90\x76\xde\x8a\x90\xc8".
       "\x5b\x05\x00\xeb\xb3\x20\xce\x6e\x5c\xb9\x35\x3d\x95\x3a\x79".
       "\x4a\x60\xeb\x23\x11\xfb\x90\x2d\xf6\xb7\x05\x4a\x43\x41\x79".
       "\x51\xaa\xe6\x90\x0a\x71\x87\x80\xbe\xb0\x89\x0f\xd3\x84\x19".
       "\xce\x6c\xf9\xbb\x1b\x15\x4d\x0f\x33\x65\xf7\x9e\x3a\xd9\x8c".
       "\x02\x43\xcf\xdf\xb2\x60\xc1\x4c\xe9\xa5\x3c\xaf\xfa\x41\x2d".
       "\xb9\x1f\x45\x32\xcb\x39\x2f\x94\xae\x44\x6d\x69\xc1\xc9\x57".
       "\x8c\xe5\xf4\xa4\x3a\xb6\x70\x61\xf9\xbb\x41\xdc\x78\xf0\xf7".
       "\xbf\xa8\x8e\xe3\x77\x51\xce\x25\x2f\xdf\x27\x6b\x07\x30\x9f".
       "\xce\xdb\x59\x58\xaa\xb2\x2e\xdc\x90\x92\x82\x55\xfe\x25\x36".
       "\x49\x7f\x6d\x2d\x39\x51\xef\x3d\xc8\xa3\x87\x0b\xe7\xf2\xac".
       "\x90\xa0\x1d\xd8\xc7\xea\x93\x53\x3b\x21\x84\x2e\x52\x6c\xfb".
       "\x4f\x31\xda\xd1\xea\x45\x3e\xdc\xeb\x52\x81\x8c\x2b\xf4\x2a".
       "\xbc\x01\xc4\xe7\x68\x36\x9c\xd5\x2d\xc1\x61\xcb\x9a\x5f\x18".
       "\x00\x6a\xc8\x9a\x4e\xfd\x31\x5b\xce\x90\x4e\x45\xff\x7f\xea".
       "\xb2\x26\xad\xc1\x3a\x21\xa9\xe8\x7c\x14\xae\x81\x1e\xbe\xa3".
       "\x6d\xda\x92\x1b\xeb\xf2\x69\x76\x3e\xf1\x2b\xf7\x1a\x45\xd5".
       "\xb3\x81\xb1\xbe\x80\x7f\x24\xba\x0e\xd5\x68\x34\x3f\x1a\x29".
       "\x15\x0e\xc2\x26\x62\x0c\xaa\xa9\x20\x4c\x61\x65\x49\x07\xbe".
       "\x69\xf4\xc9\xec\x2f\x1c\xfa\x59\x2e\x72\xc0\x17\xc5\x4c\xfa".
       "\xba\x2f\x64\xab\xa9\xb4\xcb\xdc\xcb\x25\x5f\xcf\x0c\x87\xcc".
       "\xf0\x36\x2b\xce\x81\x5a\x22\x85\xa0\x50\x50\x97\x8e\xda\x36".
       "\x80\x74\xb5\x1e\x02\x3f\xd7\xc8\x29\x11\xeb\x1d\x3d\x74\x9f".
       "\x26\x1a\xa4\x3d\xf9\x0e\xf0\x2d\x5c\xa9\x43\xbf\x51\x6c\x8d".
       "\xe6\x78\xe0\x67\x57\xf0\xc8\x0e\x97\x9c\x57\x23\x30\xac\x63".
       "\xdf\x46\x98\xa4\xaf\x4e\xa7\xe5\xac\x31\xbd\xeb\x6a\xa0\xb0".
       "\xe4\x94\x7e\x51\xf6\x89\x81\x3e\xab\x4f\x64\xb7\xc5\x51\x71".
       "\xcd\x74\x02\xa9\x02\x99\x5c\xab\x0e\x14\x47\x3b\x04\xc1\x9b".
       "\x59\x1a\x93\x92\x4c\x71\x20\x5f\x6e\xd3\xf3\xa7\x47\x1b\x39".
       "\x3e\x73\x69\xe2\xec\xcb\x52\xb3\x5c\x7a\x95\x25\x3f\x16\x98".
       "\x60\xa8\xa2\x5d\xc4\x5a\x67\xe4\x11\x06\x06\xf9\x7a\xb4\x14".
       "\xe0\xbc\x7b\x13\x1d\x0f\xf2\xca\x0b\xd4\xaa\x71\x35\x3e\xd6".
       "\x2e\x2e\x5d\x7b\x15\xc9\x23\x1a\xa9\x24\x31\x48\xd4\xcf\x4a".
       "\xf4\x32\x17\x9b\x1d\x4b\xfe\x49\x69\xd6\xc0\x8f\xb9\xdb\x72".
       "\x52\x2c\xe8\xf3\xc4\xfc\x46\xf5\xb8\x1b\x05\x06\xcf\xcc\x23".
       "\x34\xbf\x25\x6a\xea\x3c\xc7\x64\xd4\xd5\xb3\x67\xed\x24\x27".
       "\xd3\x67\xc1\xbd\x9f\x7b\x7d\x19\x04\x5c\xd1\x96\x7e\xa5\xc7".
       "\xbb\xb2\x84\x68\x98\x38\x11\x90\xfb\x62\x15\xfd\xe6\xb7\x24".
       "\x77\xb2\x78\xc7\x73\x91\xc9\x60\x1d\x91\x6d\x04\x2b\x41\xe9".
       "\xc9\xfa\xe4\x98\x54\x83\x9a\x6e\x76\x8c\x21\xf9\x91\x38\x1f".
       "\xdc\xfe\x13\x09\x30\xd7\x53\x63\x62\xba\xe3\x2c\x70\xd5\xfc".
       "\x78\x35\x36\x79\x5d\xb6\x0e\x35\x3d\x46\x87\xfb\xf5\x64\x1f".
       "\x3e\xfd\x2f\x1c\xbb\xed\x95\x2d\xd6\x63\xdc\xa7\x6a\x39\x8f".
       "\xbd\xcb\x79\x95\xe9\x45\xbf\xe4\x3e\x05\x55\x00\xdb\x33\x28".
       "\x3a\x6c\xe2\x35\xbb\xac\x70\x52\x2b\xac\x4e\x11\x44\x58\x16".
       "\x21\xb4\xae\x0d\x6a\xb9\xdc\x85\x5d\x90\x11\x26\x85\xdb\xc3".
       "\xf0\x38\x6f\x8a\xff\x12\xf0\xc9\x9e\xf0\xfc\xae\x94\x11\x4d".
       "\xce\x96\x29\x09\x6c\xf4\x2a\x6c\xda\x1e\x4c\x4a\xa2\x96\x5a".
       "\xef\xc6\x38\x5c\x60\xa2\x28\x13\x58\x73\x96\xde\x59\x2a\x57".
       "\x64\x6c\x14\x94\x8a\x2e\x8e\x21\x3f\xa2\x43\xde\xf6\x2d\x23".
       "\x74\x5c\xbd\x7a\x10\xdb\x17\xa8\x93\xd0\x74\x86\x9d\x33\x07".
       "\x48\xee\xac\x18\x6d\x64\x61\x7b\x61\x2b\xa4\xa2\xab\x99\x59".
       "\xbe\x19\xd7\x19\x41\x1e\x61\x87\xad\x40\x5b\x69\x8c\x32\xf5".
       "\xb6\x49\xbe\x1f\xad\xd8\x0f\x3e\xd9\x62\xac\x3a\x76\xde\x32".
       "\xa3\xb2\x41\x95\xad\x17\x23\xab\xa1\x37\x9c\xab\x73\x79\x70".
       "\xd6\x66\x0d\x6e\x4d\x8b\xa0\xac\xe3\x44\x1e\x0a\xee\xf0\x74".
       "\x64\xd8\x44\xd1\x6c\xa6\xd5\x36\x2e\xd9\x55\x6e\x90\x63\xb7".
       "\xf7\x8e\xc6\x28\xa3\x40\x00\x60\x9a\x3c\xfe\xff\x03\x30\x11".
       "\x18\x92\x2f\x5b\x23\xe1\x4e\x99\xe4\x82\xc9\x51\xe2\x15\x6a".
       "\x76\x5c\x67\xae\xa3\xa2\x9c\x85\x51\xe0\x44\x89\x63\xa5\x71".
       "\x99\xbc\x2d\x9c\xab\x9a\xfb\x20\x37\x58\xd6\x2d\x8b\x7d\x42".
       "\x13\x35\x44\x4c\x11\x97\x66\x27\x17\xac\x44\xe8\x6a\x03\x78".
       "\xa2\x88\xc6\x36\x71\x5a\x5a\x5a\x72\xa3\xe9\x72\x0c\x91\x31".
       "\xfc\xae\x7b\xa0\x75\x21\x0a\xc1\x4b\x95\xcb\xe3\xc2\xee\x03".
       "\x0f\xb8\xb2\x51\xc7\xc8\x9c\x8d\x6d\x3a\xe7\x4e\x2c\xaa\xeb".
       "\x5e\x49\x93\xe0\x8f\xa1\x54\x93\xe7\x7c\x5d\x31\xc7\x05\x00".
       "\x28\x14\x57\x47\xb3\x05\x2d\x17\x92\x28\x45\xee\x85\x3a\x59".
       "\xb6\xa6\x04\xc0\x5c\x07\x1f\xe6\x5b\x36\x53\x62\x82\x64\xd5".
       "\xb6\xf2\xf5\x67\x19\x11\xee\xd2\x70\xc5\x14\x63\xc1\x75\xe1".
       "\x24\xe5\x01\x59\x52\x7c\x88\x17\xb4\xe0\x15\xe9\x12\x05\xcd".
       "\x88\x7a\xd5\xea\x45\xc3\xbb\x65\xd4\xdd\x0d\xde\x36\x94\x98".
       "\x0d\x2c\xfb\x3c\x2f\x69\xd0\x28\xe2\x85\xd9\x27\xf3\x7a\xad".
       "\x50\x68\x96\x54\x5e\xeb\xbc\x2a\x74\xde\xf3\x4e\x8b\x27\x0a".
       "\xcf\x4c\x60\x40\xe8\xc5\x72\xab\x8c\xfd\xe9\xab\xff\x51\xe5".
       "\xd6\xea\x9e\x34\x73\xe1\xe6\xf8\x5b\xb1\x10\xf0\xf9\x2d\x23".
       "\x0e\xfe\xe5\xf4\x8d\xb6\x6d\x37\x14\xed\x54\x97\x92\x5c\x68".
       "\x40\x88\xf1\x43\x29\xef\x5e\x96\x77\xa2\xe8\x3c\xae\x7f\xb1".
       "\x99\x17\xa7\x0c\x6f\xe2\x43\x32\x9b\x14\x43\xf2\x15\x6b\x13".
       "\x10\x68\x56\x0b\xaa\x06\x2e\xc0\xf8\xde\x9e\x54\x9d\xba\xff".
       "\x76\x26\x6d\x5e\x9e\x88\x3a\x2b\x9b\x20\x43\xb9\x1a\x0e\x58".
       "\x65\xec\xdb\x9e\x97\xb8\xfb\x03\x6c\xb0\x7f\xa2\xf1\xf4\x27".
       "\x24\x21\x47\x51\x21\x40\x45\x28\x71\xf7\xa1\x6b\xbe\x0e\xc8".
       "\x3f\x9b\xda\x62\x9d\x73\xf7\x5f\x70\x6c\xba\x1e\xeb\x16\x5c".
       "\x2e\x44\x0a\x22\x02\x6c\xbe\xb9\x69\x93\xfd\xa5\x33\x26\x64".
       "\x24\x6c\xc2\x3d\x2f\xf3\xd1\x97\xde\x60\x43\x1c\x0d\x1b\x94".
       "\xb3\x48\x45\x7c\xd5\xd0\x71\x4d\xad\xbf\xa4\x0a\x22\x27\x04".
       "\x38\x84\x19\x66\x63\xf0\xf3\xfc\xb0\xf3\x1d\xea\xba\xb9\xe4".
       "\xe5\x80\xed\xe3\xf1\x78\x24\xc3\x25\x27\x71\x81\xc2\xec\x54".
       "\xed\xcc\x63\xf7\x39\xcd\x83\xdf\x32\x88\xc0\x3b\xd4\x62\xb8".
       "\xea\x34\xd8\xcf\xbc\x3a\x89\x38\x64\x60\x44\xde\xb6\x76\x59".
       "\xb1\x95\x6a\x26\x08\xf0\xf4\x71\x25\x8b\xf8\x81\xdd\x0d\x2f".
       "\x8c\xe2\x70\xc2\x96\xc2\xd8\x9b\xe4\x3f\xec\x8b\xfd\xbd\xc9".
       "\x36\x33\xb7\xbc\x59\x37\x19\x09\x30\x5e\xef\x67\xae\x67\x48".
       "\x72\x0b\xf4\x2a\x82\xff\xcb\xd7\xd9\x9d\x6d\x7c\xa6\x20\x42".
       "\x50\x2b\x0a\x2f\x45\x99\x5b\x76\x6d\x99\x39\xa9\xb6\x32\x06".
       "\x11\xf8\x19\xd1\x3f\xc0\xd6\x1f\x67\xfa\xd5\xae\x7a\x71\x8c".
       "\xbc\x3d\xb4\x5f\x5c\x81\x7c\xa1\x39\x70\x0a\x17\x24\xb7\x22".
       "\x86\x50\xd8\x1f\xc8\x6c\x59\x9a\xdc\xf0\x71\x01\xda\xd8\x53".
       "\x98\x1c\x73\x36\xf1\x09\x86\xc9\xa7\x26\x25\xc0\x03\x3e\x13".
       "\x4e\x29\xeb\xf0\x8d\xe3\x38\x03\x54\xee\x37\xfb\x51\x2e\xb4".
       "\xf6\x12\x1f\xb2\x8c\x66\x75\x00\x30\x5b\xef\x59\xf9\x63\xa9".
       "\x74\x07\x91\xe4\x9c\xb7\xc9\x89\xd9\xa9\x51\x93\xcb\xb1\xa7".
       "\x64\x08\x79\x8f\xb4\x6d\x09\xd7\xc5\xbf\x0a\xdb\x50\xe0\x1c".
       "\x83\xca\xf8\xcf\xa7\x81\xbb\x0b\xe6\xcf\x1b\x0e\x0a\xe0\xcd".
       "\x68\xe2\xde\xc4\x2d\xba\x55\xc7\xc7\x1e\x6c\x5e\xca\x9b\x20".
       "\x75\x96\x94\x92\x84\xec\xf5\x22\x25\x78\x67\xcd\xbe\x01\xfe".
       "\x53\xa5\xcc\x6a\x40\x33\x83\xa4\x7a\x44\x93\x0b\xf9\x4c\xb2".
       "\x95\xb6\x7e\x4b\xa4\xc8\x86\xfe\x8a\xf1\x77\x40\x56\x13\xc1".
       "\x31\x2c\x8c\x4a\xa8\x89\x61\x0c\x39\x33\x78\x8c\xd5\x50\x3b".
       "\x89\xc3\xd3\x80\x1c\xa7\xb6\x36\xc2\x00\x8d\x0a\x7f\xcc\xd3".
       "\x20\x74\x60\x70\x36\x7d\xda\xdc\xc4\x49\x04\xf0\xe6\x6c\xd1".
       "\xbe\xcb\xfb\xf1\xa2\xd6\xd4\xe4\x97\x3f\x35\x09\x5b\xda\x06".
       "\x6b\x6d\x86\x53\x23\x0c\x26\x51\x2a\x15\xaa\xe2\x73\xfb\xc7".
       "\x41\x54\xdc\x5d\x99\x0b\x0a\x1e\xd4\xdb\x70\xa3\x8e\xfd\x5b".
       "\xf0\xa8\x3e\x9b\xff\x57\x98\xbc\xd9\x2a\x56\xd3\x19\xf9\x0b".
       "\xd9\x67\x0f\x10\x9c\x23\xe5\x6b\x12\xc6\xb6\x4b\xd1\x0c\xe9".
       "\x45\x36\xdf\x54\x6f\xcc\xfe\xb5\xcc\xb9\xfe\xde\xc8\xb5\xc9".
       "\x04\x59\x61\x75\x1e\x72\x37\x54\xfd\xc6\xc3\x7e\x74\xae\x55".
       "\x31\x6a\xbc\x8a\xd8\x45\x91\xe2\x8d\x20\x97\x71\xe7\x55\xd6".
       "\x8a\xb8\x82\x2a\x27\x4f\xdc\x53\x89\x28\xf7\x3a\xfe\x07\xef".
       "\x60\xb2\x32\x7c\xbc\x13\xc4\x3d\xda\xd7\xfb\xb8\x61\x7d\x69".
       "\xae\x0e\x9a\x71\xd6\x00\x26\x97\xff\xdb\xe6\xbe\x45\x7a\xb5".
       "\x00\x31\xfd\x70\xcc\xd7\x34\x88\xe4\x05\x61\xf5\x72\x1d\x14".
       "\xf0\x7e\x90\xdb\x0e\xc7\xda\xd4\xf3\x99\xd4\x60\xd9\xa7\xc8".
       "\x5b\x33\x34\xb5\x23\x74\x2c\x5f\x6b\x56\x95\x9c\x1b\x2a\xac".
       "\xf9\xfe\x46\xc3\xf1\x9b\x24\x7e\x4b\xca\x25\x58\x41\x10\x63".
       "\xe8\xe7\x68\xda\xcc\xb6\x4d\x5b\x8f\xc9\xa9\x31\xeb\x5c\x2a".
       "\xcf\x9d\x89\xd5\x51\x93\x80\x30\xf4\xc9\x2c\x8c\xb8\x8c\x62".
       "\xd6\x33\xbd\x95\x9f\xfa\x19\xf2\x48\x28\x09\x73\xc9\x53\x61".
       "\x94\x3a\x62\x68\x6c\xc6\xd6\x0a\xb4\xae\x27\x96\xfb\x29\xd7".
       "\x46\x67\x11\x7a\xe8\x3a\x9a\x3f\xf4\x9a\x75\xed\x24\x67\x45".
       "\x79\xdc\x8b\x19\xf2\xef\x57\xaa\xc7\x84\xff\x9d\x2d\xc3\xa8".
       "\x85\x54\xb7\x9d\xe1\xd6\x2b\xe9\x31\x9d\x6c\xb8\x4e\x76\x50".
       "\x80\x44\x46\x8f\x5e\x7e\x20\xaa\xa0\x8a\x36\x6b\xef\xd1\x75".
       "\xf8\x3f\x20\xdd\x09\x73\xbf\xa5\xf7\xb4\x87\xb2\x44\xc0\x0f".
       "\x10\xc0\x95\x2e\x8a\x42\xfa\xc3\x49\x17\xb9\xb5\x1a\xc3\x80".
       "\x93\x0c\xd8\xe3\xcd\xa4\x38\x61\x7a\x22\x73\x8e\x32\x8f\x55".
       "\x9c\x91\x08\xd9\x65\xa9\x02\x28\xc6\x59\xc8\x51\x32\x20\x48".
       "\xea\x2c\xae\x0e\xa6\x35\x5b\xe2\x63\xf9\xf2\x9d\x5f\xe3\x45".
       "\xdc\x41\xba\xfb\x40\xcc\x8d\xde\x6c\x3d\x50\x97\x9d\x83\xa0".
       "\xda\x41\x61\xba\xaf\xf8\x74\xd2\x21\x7b\x09\xcc\x83\xe1\x08".
       "\x01\x04\x42\xce\xcb\xec\x1d\x6b\xb7\x6f\x0f\x4b\xd4\x53\x90".
       "\x55\x3b\xcf\x9f\x93\xb8\xad\xce\x5f\x13\x83\xb3\x89\x6f\x5a".
       "\x1b\xa4\xf5\x95\x4b\xb4\x22\x22\x1d\x35\xaa\xfa\xc7\x14\x8c".
       "\xcd\x50\x66\x14\x47\xff\x67\xb2\xf8\x12\x09\xb3\x8a\xe5\x7d".
       "\xb8\xc9\xe4\x89\xf7\xa4\xb5\x70\xfa\x2d\xeb\x95\x89\xec\xbb".
       "\x49\x59\xd2\xc1\x6d\x0e\x06\xe4\x5e\xd5\x13\x13\x0d\x72\x6e".
       "\xf0\x6d\xa9\xd5\xe7\x54\x68\x35\xcd\xd0\xd5\xa6\xe5\xb2\xe4".
       "\xb1\x19\xe4\xf1\xe3\x8a\x56\x4c\x3b\x3d\xb8\x03\xfe\x22\x2f".
       "\xc6\xdc\x88\x7b\xca\x5c\xc6\xdd\x17\x34\x08\x22\xf0\x17\x61".
       "\x0e\x60\x9c\xb4\x27\x57\x30\x6e\xb8\x4f\xdd\x25\x7b\xef\x9e".
       "\x8e\x88\x6b\xd8\x10\x23\xc2\x44\x53\x73\x64\x8f\x40\x22\xe1".
       "\xe8\xa2\xb0\x3f\x8a\x07\x66\xcd\x64\x4f\x9c\x1e\x89\x76\x04".
       "\x6d\xab\xc2\xbb\x16\x85\x80\x01\xa5\xb1\xe2\x12\x04\x2e\x39".
       "\x87\x8c\xee\xbc\xfb\x07\x6d\x03\x4c\x3a\xa5\x7b\x95\xd9\xd7".
       "\xd6\xee\x2b\xe9\xcb\xe6\xec\xa8\x84\x6a\x42\xf9\xb2\x25\xc8".
       "\xf3\x6a\xaa\x34\x3b\xd9\x72\xd9\x70\x81\x3b\xd4\x5e\x66\x97".
       "\x1b\xe6\x2b\x88\x71\x82\xa3\x8a\x98\xb0\x16\xd9\xbb\x97\x8b".
       "\x57\x79\x41\x56\x6e\xc2\x8f\xdf\xfa\x5b\xc7\x68\x5b\xb8\x09".
       "\x41\x31\x7c\x19\xe1\x95\x2e\x05\x4c\xac\x38\x81\xda\xb3\x8b".
       "\x3e\x1c\x79\x9a\x31\xac\x3e\x3d\x6d\xab\xf3\x5a\x5e\xc7\x6e".
       "\x8e\x39\xcd\x7b\x6f\x62\xee\xb9\x73\xdd\x82\x42\x6f\x09\xe4".
       "\xc3\xae\x92\xe8\x18\x99\xa0\x5e\xa2\x12\xf4\xe2\xe0\xe6\x95".
       "\x58\x3a\x45\xad\xfe\x23\x79\x5f\x82\xce\x95\x88\x73\xeb\x46".
       "\xc8\x00\xac\xc3\x2a\xdc\x7e\xab\x9b\xf8\xbb\x46\x5c\xa8\x46".
       "\xbc\xfd\x99\xae\x4c\xa7\x77\xeb\x7c\x58\xbf\xbb\x52\x68\x62".
       "\x3d\x0b\x79\x64\x38\x65\xa7\xcb\x7b\xe9\xb2\x33\xb5\x59\x52".
       "\x7b\x17\xb4\x02\x2b\x07\x0d\x3a\x11\x57\x92\xa5\x22\x2b\xbc".
       "\xe6\x97\x05\x12\x05\xe7\x91\xe3\xfa\xae\x15\xbe\x20\xe5\x5c".
       "\x71\x24\x80\x85\xc9\x66\xc1\x53\x5c\x8f\x08\xd4\x52\xe1\x10".
       "\xb6\xd6\x20\x08\x01\x79\x33\x9f\x1b\xbd\xa0\xab\x7c\xb1\xd9".
       "\xdc\xca\x44\x22\x49\xb7\xb7\x3d\x84\xac\x92\xf4\xfa\x0a\xc9".
       "\xc5\xb2\x42\x2b\x9a\x63\xbb\x8a\x82\x04\x2f\xf7\xe9\x30\x05".
       "\x67\x32\xd1\x41\x1a\x69\x6e\xb9\xf8\x5f\x6d\xb7\xe5\x4e\x85".
       "\x21\xfa\x16\x8a\x44\xfd\xf6\xd9\xa2\x5f\x68\x2b\xf3\xe2\x3c".
       "\x8a\x69\xd2\xc1\x38\xed\x83\xef\x0d\x53\x86\x93\x32\x23\xc6".
       "\x14\x0c\xb0\xb6\x6e\x77\xa4\x20\x0f\xb1\x6e\xe2\xce\xca\x6f".
       "\x93\x1c\x3a\x8f\xd0\xd2\x5a\x6e\x30\xd6\x8e\x5f\x4b\xa5\xef".
       "\xa9\x62\xeb\x28\xa0\x5e\x3f\xc1\xbc\x0a\x68\xab\xd7\xfa\xa2".
       "\xb7\x8f\x12\xb0\x99\xbc\x93\x20\xb8\x95\x8d\xca\xc7\xa7\xd9".
       "\x2e\x19\xac\x06\xb9\x4e\x56\x8e\x74\xef\x2a\x04\xd8\x75\x04".
       "\x38\x2a\xc7\xa0\xa4\x89\xf3\xa4\x8a\xd4\x2c\x2c\x58\x6f\x00".
       "\x03\x23\xb8\xaf\x02\x48\x7d\x50\x46\x6f\x5a\x08\x41\xe3\x56".
       "\x6d\xcb\xe2\x4f\xea\x8e\xab\x74\xcd\xf9\xef\xcf\xf9\x1e\xf1".
       "\xf8\xb9\x6c\xaa\x3b\x37\xd1\x21\x42\x67\xec\xd6\x44\x55\x33".
       "\xe8\x1d\xa4\x18\xf3\x73\x82\xb4\x50\x59\xc2\x34\x36\x05\xeb";
 
     $expect = Filesystem::readFile(dirname(__FILE__).'/base85/expect2.txt');
     $expect = trim($expect);
 
     $this->assertEqual(
       $expect,
       ArcanistBundle::encodeBase85($data));
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index 45bae424..3f24d984 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,1099 +1,1173 @@
 <?php
 
 /**
  * Interfaces with Git working copies.
  *
  * @group workingcopy
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $repositoryHasNoCommits = false;
   const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;
 
   /**
    * For the repository's initial commit, 'git diff HEAD^' and similar do
    * not work. Using this instead does work; it is the hash of the empty tree.
    */
   const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 
+  private $symbolicHeadCommit = 'HEAD';
+  private $resolvedHeadCommit;
+
   public static function newHookAPI($root) {
     return new ArcanistGitAPI($root);
   }
 
   protected function buildLocalFuture(array $argv) {
 
     $argv[0] = 'git '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
 
     static $git = null;
     if ($git === null) {
       if (phutil_is_windows()) {
         // NOTE: On Windows, phutil_passthru() uses 'bypass_shell' because
         // everything goes to hell if we don't. We must provide an absolute
         // path to Git for this to work properly.
         $git = Filesystem::resolveBinary('git');
         $git = csprintf('%s', $git);
       } else {
         $git = 'git';
       }
     }
 
     $args[0] = $git.' '.$args[0];
 
     return call_user_func_array('phutil_passthru', $args);
   }
 
 
   public function getSourceControlSystemName() {
     return 'git';
   }
 
   public function getMetadataPath() {
     static $path = null;
     if ($path === null) {
       list($stdout) = $this->execxLocal('rev-parse --git-dir');
       $path = rtrim($stdout, "\n");
       // the output of git rev-parse --git-dir is an absolute path, unless
       // the cwd is the root of the repository, in which case it uses the
       // relative path of .git. If we get this relative path, turn it into
       // an absolute path.
       if ($path === '.git') {
         $path = $this->getPath('.git');
       }
     }
     return $path;
   }
 
   public function getHasCommits() {
     return !$this->repositoryHasNoCommits;
   }
 
+  /**
+   * Tests if a child commit is descendant of a parent commit.
+   * If child and parent are the same, it returns false.
+   * @param child commit SHA.
+   * @param parent commit SHA.
+   * @return bool
+   */
+  private function isDescendant($child, $parent) {
+    list($common_ancestor) =
+      $this->execxLocal('merge-base %s %s', $child, $parent);
+    $common_ancestor = trim($common_ancestor);
+
+    return $common_ancestor == $parent && $common_ancestor != $child;
+  }
+
   public function getLocalCommitInformation() {
     if ($this->repositoryHasNoCommits) {
       // Zero commits.
       throw new Exception(
         "You can't get local commit information for a repository with no ".
         "commits.");
     } else if ($this->getBaseCommit() == self::GIT_MAGIC_ROOT_COMMIT) {
       // One commit.
       $against = 'HEAD';
     } else {
 
       // 2..N commits. We include commits reachable from HEAD which are
       // not reachable from the relative commit; this is consistent with
       // user expectations even though it is not actually the diff range.
       // Particularly:
       //
       //    |
       //    D <----- master branch
       //    |
       //    C  Y <- feature branch
       //    | /|
       //    B  X
       //    | /
       //    A
       //    |
       //
       // If "A, B, C, D" are master, and the user is at Y, when they run
       // "arc diff B" they want (and get) a diff of B vs Y, but they think about
       // this as being the commits X and Y. If we log "B..Y", we only show
       // Y. With "Y --not B", we show X and Y.
 
-      $against = csprintf('%s --not %s', 'HEAD', $this->getBaseCommit());
+      $base_commit = $this->getBaseCommit();
+      $head_commit = $this->getHeadCommit();
+      if ($this->isDescendant($head_commit, $base_commit) === false) {
+        throw new ArcanistUsageException(
+          "base commit ${base_commit} is not a child of head commit ".
+          "${head_commit}");
+      }
+
+      $against = csprintf('%s --not %s',
+        $this->getHeadCommit(), $this->getBaseCommit());
     }
 
     // NOTE: Windows escaping of "%" symbols apparently is inherently broken;
     // when passed throuhgh escapeshellarg() they are replaced with spaces.
 
     // TODO: Learn how cmd.exe works and find some clever workaround?
 
     // NOTE: If we use "%x00", output is truncated in Windows.
 
     list($info) = $this->execxLocal(
       phutil_is_windows()
         ? 'log %C --format=%C --'
         : 'log %C --format=%s --',
       $against,
       // NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
       '%H%x01%T%x01%P%x01%at%x01%an%x01%aE%x01%s%x01%s%n%n%b%x02');
 
     $commits = array();
 
     $info = trim($info, " \n\2");
     if (!strlen($info)) {
       return array();
     }
 
     $info = explode("\2", $info);
     foreach ($info as $line) {
       list($commit, $tree, $parents, $time, $author, $author_email,
         $title, $message) = explode("\1", trim($line), 8);
       $message = rtrim($message);
 
       $commits[$commit] = array(
         'commit'  => $commit,
         'tree'    => $tree,
         'parents' => array_filter(explode(' ', $parents)),
         'time'    => $time,
         'author'  => $author,
         'summary' => $title,
         'message' => $message,
         'authorEmail' => $author_email,
       );
     }
 
     return $commits;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     if ($symbolic_commit !== null) {
       if ($symbolic_commit == ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
         $this->setBaseCommitExplanation(
           'you explicitly specified the empty tree.');
         return $symbolic_commit;
       }
 
       list($err, $merge_base) = $this->execManualLocal(
-        'merge-base %s HEAD',
-        $symbolic_commit);
+        'merge-base %s %s',
+        $symbolic_commit,
+        $this->getHeadCommit());
       if ($err) {
         throw new ArcanistUsageException(
           "Unable to find any git commit named '{$symbolic_commit}' in ".
           "this repository.");
       }
 
       $this->setBaseCommitExplanation(
-        "it is the merge-base of '{$symbolic_commit}' and HEAD, as you ".
-        "explicitly specified.");
+        "it is the merge-base of '{$symbolic_commit}' and ".
+        "{$this->symbolicHeadCommit}, as you explicitly specified.");
       return trim($merge_base);
     }
 
     // Detect zero-commit or one-commit repositories. There is only one
     // relative-commit value that makes any sense in these repositories: the
     // empty tree.
     list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
     if ($err) {
       list($err) = $this->execManualLocal('rev-parse --verify HEAD');
       if ($err) {
         $this->repositoryHasNoCommits = true;
       }
 
       if ($this->repositoryHasNoCommits) {
         $this->setBaseCommitExplanation(
           'the repository has no commits.');
       } else {
         $this->setBaseCommitExplanation(
           'the repository has only one commit.');
       }
 
       return self::GIT_MAGIC_ROOT_COMMIT;
     }
 
     if ($this->getBaseCommitArgumentRules() ||
         $this->getConfigurationManager()->getConfigFromAnySource('base')) {
       $base = $this->resolveBaseCommit();
       if (!$base) {
         throw new ArcanistUsageException(
           "None of the rules in your 'base' configuration matched a valid ".
           "commit. Adjust rules or specify which commit you want to use ".
           "explicitly.");
       }
       return $base;
     }
 
     $do_write = false;
     $default_relative = null;
     $working_copy = $this->getWorkingCopyIdentity();
     if ($working_copy) {
       $default_relative = $working_copy->getProjectConfig(
         'git.default-relative-commit');
       $this->setBaseCommitExplanation(
         "it is the merge-base of '{$default_relative}' and HEAD, as ".
         "specified in 'git.default-relative-commit' in '.arcconfig'. This ".
         "setting overrides other settings.");
     }
 
     if (!$default_relative) {
       list($err, $upstream) = $this->execManualLocal(
         "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
 
       if (!$err) {
         $default_relative = trim($upstream);
         $this->setBaseCommitExplanation(
           "it is the merge-base of '{$default_relative}' (the Git upstream ".
           "of the current branch) HEAD.");
       }
     }
 
     if (!$default_relative) {
       $default_relative = $this->readScratchFile('default-relative-commit');
       $default_relative = trim($default_relative);
       if ($default_relative) {
         $this->setBaseCommitExplanation(
           "it is the merge-base of '{$default_relative}' and HEAD, as ".
           "specified in '.git/arc/default-relative-commit'.");
       }
     }
 
     if (!$default_relative) {
 
       // TODO: Remove the history lesson soon.
 
       echo phutil_console_format(
         "<bg:green>** Select a Default Commit Range **</bg>\n\n");
       echo phutil_console_wrap(
         "You're running a command which operates on a range of revisions ".
         "(usually, from some revision to HEAD) but have not specified the ".
         "revision that should determine the start of the range.\n\n".
         "Previously, arc assumed you meant 'HEAD^' when you did not specify ".
         "a start revision, but this behavior does not make much sense in ".
         "most workflows outside of Facebook's historic git-svn workflow.\n\n".
         "arc no longer assumes 'HEAD^'. You must specify a relative commit ".
         "explicitly when you invoke a command (e.g., `arc diff HEAD^`, not ".
         "just `arc diff`) or select a default for this working copy.\n\n".
         "In most cases, the best default is 'origin/master'. You can also ".
         "select 'HEAD^' to preserve the old behavior, or some other remote ".
         "or branch. But you almost certainly want to select ".
         "'origin/master'.\n\n".
         "(Technically: the merge-base of the selected revision and HEAD is ".
         "used to determine the start of the commit range.)");
 
       $prompt = 'What default do you want to use? [origin/master]';
       $default = phutil_console_prompt($prompt);
 
       if (!strlen(trim($default))) {
         $default = 'origin/master';
       }
 
       $default_relative = $default;
       $do_write = true;
     }
 
     list($object_type) = $this->execxLocal(
       'cat-file -t %s',
       $default_relative);
 
     if (trim($object_type) !== 'commit') {
       throw new Exception(
         "Relative commit '{$default_relative}' is not the name of a commit!");
     }
 
     if ($do_write) {
       // Don't perform this write until we've verified that the object is a
       // valid commit name.
       $this->writeScratchFile('default-relative-commit', $default_relative);
       $this->setBaseCommitExplanation(
         "it is the merge-base of '{$default_relative}' and HEAD, as you ".
         "just specified.");
     }
 
     list($merge_base) = $this->execxLocal(
       'merge-base %s HEAD',
       $default_relative);
 
     return trim($merge_base);
   }
 
+  public function getHeadCommit() {
+    if ($this->resolvedHeadCommit === null) {
+      $this->resolvedHeadCommit =
+        $this->resolveCommit($this->symbolicHeadCommit);
+    }
+
+    return $this->resolvedHeadCommit;
+  }
+
+  final public function setHeadCommit($symbolic_commit) {
+    $this->symbolicHeadCommit = $symbolic_commit;
+    $this->reloadCommitRange();
+    return $this;
+  }
+
+  /**
+   * Translates a symbolic commit (like "HEAD^") to a commit identifier.
+   * @param string_symbol commit.
+   * @return string the commit SHA.
+   */
+  private function resolveCommit($symbolic_commit) {
+    list($err, $commit_hash) = $this->execManualLocal(
+      'rev-parse %s',
+      $symbolic_commit);
+
+    if ($err) {
+      throw new ArcanistUsageException(
+        "Unable to find any git commit named '{$symbolic_commit}' in ".
+        "this repository.");
+    }
+
+    return trim($commit_hash);
+  }
+
   private function getDiffFullOptions($detect_moves_and_renames = true) {
     $options = array(
       self::getDiffBaseOptions(),
       '--no-color',
       '--src-prefix=a/',
       '--dst-prefix=b/',
       '-U'.$this->getDiffLinesOfContext(),
     );
 
     if ($detect_moves_and_renames) {
       $options[] = '-M';
       $options[] = '-C';
     }
 
     return implode(' ', $options);
   }
 
   private function getDiffBaseOptions() {
     $options = array(
       // Disable external diff drivers, like graphical differs, since Arcanist
       // needs to capture the diff text.
       '--no-ext-diff',
       // Disable textconv so we treat binary files as binary, even if they have
       // an alternative textual representation. TODO: Ideally, Differential
       // would ship up the binaries for 'arc patch' but display the textconv
       // output in the visual diff.
       '--no-textconv',
     );
     return implode(' ', $options);
   }
 
-  public function getFullGitDiff() {
+  /**
+   * @param the base revision
+   * @param head revision. If this is null, the generated diff will include the
+   * working copy
+   */
+  public function getFullGitDiff($base, $head=null) {
     $options = $this->getDiffFullOptions();
+
+    $diff_revision = $base;
+    if ($head) {
+      $diff_revision .= '..'.$head;
+    }
+
     list($stdout) = $this->execxLocal(
       "diff {$options} %s --",
-      $this->getBaseCommit());
+      $diff_revision);
     return $stdout;
   }
 
   /**
    * @param string Path to generate a diff for.
    * @param bool   If true, detect moves and renames. Otherwise, ignore
    *               moves/renames; this is useful because it prompts git to
    *               generate real diff text.
    */
   public function getRawDiffText($path, $detect_moves_and_renames = true) {
     $options = $this->getDiffFullOptions($detect_moves_and_renames);
     list($stdout) = $this->execxLocal(
       "diff {$options} %s -- %s",
       $this->getBaseCommit(),
       $path);
     return $stdout;
   }
 
   public function getBranchName() {
     // TODO: consider:
     //
     //    $ git rev-parse --abbrev-ref `git symbolic-ref HEAD`
     //
     // But that may fail if you're not on a branch.
     list($stdout) = $this->execxLocal('branch --no-color');
 
     // Assume that any branch beginning with '(' means 'no branch', or whatever
     // 'no branch' is in the current locale.
     $matches = null;
     if (preg_match('/^\* ([^\(].*)$/m', $stdout, $matches)) {
       return $matches[1];
     }
 
     return null;
   }
 
   public function getRemoteURI() {
     list($stdout) = $this->execxLocal('remote show -n origin');
 
     $matches = null;
     if (preg_match('/^\s*Fetch URL: (.*)$/m', $stdout, $matches)) {
       return trim($matches[1]);
     }
 
     return null;
   }
 
   public function getSourceControlPath() {
     // TODO: Try to get something useful here.
     return null;
   }
 
   public function getGitCommitLog() {
     $relative = $this->getBaseCommit();
     if ($this->repositoryHasNoCommits) {
       // No commits yet.
       return '';
     } else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
       // First commit.
       list($stdout) = $this->execxLocal(
         'log --format=medium HEAD');
     } else {
       // 2..N commits.
       list($stdout) = $this->execxLocal(
-        'log --first-parent --format=medium %s..HEAD',
-        $this->getBaseCommit());
+        'log --first-parent --format=medium %s..%s',
+        $this->getBaseCommit(),
+        $this->getHeadCommit());
     }
     return $stdout;
   }
 
   public function getGitHistoryLog() {
     list($stdout) = $this->execxLocal(
       'log --format=medium -n%d %s',
       self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
       $this->getBaseCommit());
     return $stdout;
   }
 
   public function getSourceControlBaseRevision() {
     list($stdout) = $this->execxLocal(
       'rev-parse %s',
       $this->getBaseCommit());
     return rtrim($stdout, "\n");
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if (preg_match('/@([0-9]+)$/', $string, $match)) {
       $stdout = $this->getHashFromFromSVNRevisionNumber($match[1]);
     } else {
       list($stdout) = $this->execxLocal(
         'show -s --format=%C %s',
         '%H',
         $string);
     }
     return rtrim($stdout);
   }
 
   private function executeSVNFindRev($input, $vcs) {
     $match = array();
     list($stdout) = $this->execxLocal(
       'svn find-rev %s',
       $input);
     if (!$stdout) {
       throw new ArcanistUsageException("Cannot find the {$vcs} equivalent "
                                        ."of {$input}.");
     }
     // When git performs a partial-rebuild during svn
     // look-up, we need to parse the final line
     $lines = explode("\n", $stdout);
     $stdout = $lines[count($lines) - 2];
     return rtrim($stdout);
   }
 
   // Convert svn revision number to git hash
   public function getHashFromFromSVNRevisionNumber($revision_id) {
     return $this->executeSVNFindRev('r'.$revision_id, 'Git');
   }
 
 
   // Convert a git hash to svn revision number
   public function getSVNRevisionNumberFromHash($hash) {
     return $this->executeSVNFindRev($hash, 'SVN');
   }
 
 
   protected function buildUncommittedStatus() {
     $diff_options = $this->getDiffBaseOptions();
 
     if ($this->repositoryHasNoCommits) {
       $diff_base = self::GIT_MAGIC_ROOT_COMMIT;
     } else {
       $diff_base = 'HEAD';
     }
 
     // Find uncommitted changes.
     $uncommitted_future = $this->buildLocalFuture(
       array(
         'diff %C --raw %s --',
         $diff_options,
         $diff_base,
       ));
 
     $untracked_future = $this->buildLocalFuture(
       array(
         'ls-files --others --exclude-standard',
       ));
 
     // Unstaged changes
     $unstaged_future = $this->buildLocalFuture(
       array(
         'diff-files --name-only',
       ));
 
     $futures = array(
       $uncommitted_future,
       $untracked_future,
       $unstaged_future,
     );
 
     Futures($futures)->resolveAll();
 
     $result = new PhutilArrayWithDefaultValue();
 
     list($stdout) = $uncommitted_future->resolvex();
     $uncommitted_files = $this->parseGitStatus($stdout);
     foreach ($uncommitted_files as $path => $mask) {
       $result[$path] |= ($mask | self::FLAG_UNCOMMITTED);
     }
 
     list($stdout) = $untracked_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNTRACKED;
       }
     }
 
     list($stdout, $stderr) = $unstaged_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNSTAGED;
       }
     }
 
     return $result->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     list($stdout, $stderr) = $this->execxLocal(
       'diff %C --raw %s --',
       $this->getDiffBaseOptions(),
       $this->getBaseCommit());
 
     return $this->parseGitStatus($stdout);
   }
 
   public function getGitConfig($key, $default = null) {
     list($err, $stdout) = $this->execManualLocal('config %s', $key);
     if ($err) {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     list($stdout) = $this->execxLocal('var GIT_AUTHOR_IDENT');
     return preg_replace('/\s+<.*/', '', rtrim($stdout, "\n"));
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'add -A -- %Ls',
       $paths);
     $this->reloadWorkingCopy();
     return $this;
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     // NOTE: "--allow-empty-message" was introduced some time after 1.7.0.4,
     // so we do not provide it and thus require a message.
 
     $this->execxLocal(
       'commit -F %s',
       $tmp_file);
 
     $this->reloadWorkingCopy();
 
     return $this;
   }
 
   public function amendCommit($message = null) {
     if ($message === null) {
       $this->execxLocal('commit --amend --allow-empty -C HEAD');
     } else {
       $tmp_file = new TempFile();
       Filesystem::writeFile($tmp_file, $message);
       $this->execxLocal(
         'commit --amend --allow-empty -F %s',
         $tmp_file);
     }
 
     $this->reloadWorkingCopy();
     return $this;
   }
 
   public function getPreReceiveHookStatus($old_ref, $new_ref) {
     $options = $this->getDiffBaseOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} --raw %s %s --",
       $old_ref,
       $new_ref);
     return $this->parseGitStatus($stdout, $full = true);
   }
 
   private function parseGitStatus($status, $full = false) {
     static $flags = array(
       'A' => self::FLAG_ADDED,
       'M' => self::FLAG_MODIFIED,
       'D' => self::FLAG_DELETED,
     );
 
     $status = trim($status);
     $lines = array();
     foreach (explode("\n", $status) as $line) {
       if ($line) {
         $lines[] = preg_split("/[ \t]/", $line, 6);
       }
     }
 
     $files = array();
     foreach ($lines as $line) {
       $mask = 0;
       $flag = $line[4];
       $file = $line[5];
       foreach ($flags as $key => $bits) {
         if ($flag == $key) {
           $mask |= $bits;
         }
       }
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => rtrim($line[3], '.'),
         );
       } else {
         $files[$file] = $mask;
       }
     }
 
     return $files;
   }
 
   public function getAllFiles() {
     $future = $this->buildLocalFuture(array('ls-files -z'));
     return id(new LinesOfALargeExecFuture($future))
       ->setDelimiter("\0");
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'diff --raw %s',
       $since_commit);
     return $this->parseGitStatus($stdout);
   }
 
   public function getBlame($path) {
     // TODO: 'git blame' supports --porcelain and we should probably use it.
     list($stdout) = $this->execxLocal(
       'blame --date=iso -w -M %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     $blame = array();
     foreach (explode("\n", trim($stdout)) as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       // lines predating a git repo's history are blamed to the oldest revision,
       // with the commit hash prepended by a ^. we shouldn't count these lines
       // as blaming to the oldest diff's unfortunate author
       if ($line[0] == '^') {
         continue;
       }
 
       $matches = null;
       $ok = preg_match(
         '/^([0-9a-f]+)[^(]+?[(](.*?) +\d\d\d\d-\d\d-\d\d/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $matches[1];
       $author = $matches[2];
 
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getBaseCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision($path, 'HEAD');
   }
 
   private function parseGitTree($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $lines = explode("\n", $stdout);
     foreach ($lines as $line) {
       $matches = array();
       $ok = preg_match(
         '/^(\d{6}) (blob|tree|commit) ([a-z0-9]{40})[\t](.*)$/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception('Failed to parse git ls-tree output!');
       }
       $result[$matches[4]] = array(
         'mode' => $matches[1],
         'type' => $matches[2],
         'ref'  => $matches[3],
       );
     }
     return $result;
   }
 
   private function getFileDataAtRevision($path, $revision) {
 
     // NOTE: We don't want to just "git show {$revision}:{$path}" since if the
     // path was a directory at the given revision we'll get a list of its files
     // and treat it as though it as a file containing a list of other files,
     // which is silly.
 
     list($stdout) = $this->execxLocal(
       'ls-tree %s -- %s',
       $revision,
       $path);
 
     $info = $this->parseGitTree($stdout);
     if (empty($info[$path])) {
       // No such path, or the path is a directory and we executed 'ls-tree dir/'
       // and got a list of its contents back.
       return null;
     }
 
     if ($info[$path]['type'] != 'blob') {
       // Path is or was a directory, not a file.
       return null;
     }
 
     list($stdout) = $this->execxLocal(
       'cat-file blob %s',
        $info[$path]['ref']);
     return $stdout;
   }
 
   /**
    * Returns names of all the branches in the current repository.
    *
    * @return list<dict<string, string>> Dictionary of branch information.
    */
   public function getAllBranches() {
     list($branch_info) = $this->execxLocal(
       'branch --no-color');
     $lines = explode("\n", rtrim($branch_info));
 
     $result = array();
     foreach ($lines as $line) {
 
       if (preg_match('@^[* ]+\(no branch|detached from \w+/\w+\)@', $line)) {
         // This is indicating that the working copy is in a detached state;
         // just ignore it.
         continue;
       }
 
       list($current, $name) = preg_split('/\s+/', $line, 2);
       $result[] = array(
         'current' => !empty($current),
         'name'    => $name,
       );
     }
 
     return $result;
   }
 
   public function getWorkingCopyRevision() {
     list($stdout) = $this->execxLocal('rev-parse HEAD');
     return rtrim($stdout, "\n");
   }
 
   public function getUnderlyingWorkingCopyRevision() {
     list($err, $stdout) = $this->execManualLocal('svn find-rev HEAD');
     if (!$err && $stdout) {
       return rtrim($stdout, "\n");
     }
     return $this->getWorkingCopyRevision();
   }
 
   public function isHistoryDefaultImmutable() {
     return false;
   }
 
   public function supportsAmend() {
     return true;
   }
 
   public function supportsCommitRanges() {
     return true;
   }
 
   public function supportsLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       if (!$this->getCanonicalRevisionName($commit)) {
         return false;
       }
     } catch (CommandException $exception) {
       return false;
     }
     return true;
   }
 
   public function getAllLocalChanges() {
-    $diff = $this->getFullGitDiff();
+    $diff = $this->getFullGitDiff($this->getBaseCommit());
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if (!$branch) {
       throw new ArcanistUsageException(
         'Under git, you must specify the branch you want to merge.');
     }
     $err = phutil_passthru(
       '(cd %s && git merge --no-ff -m %s %s)',
       $this->getPath(),
       $message,
       $branch);
 
     if ($err) {
       throw new ArcanistUsageException('Merge failed!');
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'git push', or 'git svn dcommit', or by printing and faxing it).";
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log -n1 --format=%C %s --',
       '%s%n%n%b',
       $commit);
     return $message;
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getGitCommitLog();
     if (!strlen($messages)) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $messages = $parser->parseDiff($messages);
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
         $message->getMetadata('message'));
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $message->getCommitHash();
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       return $results;
     }
 
     // If we didn't succeed, try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('gtcm', $commit['commit']);
       $hashes[] = array('gttr', $commit['tree']);
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'commitHashes' => $hashes,
       ));
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] =
         'A git commit or tree hash in the commit range is already attached '.
         'to the Differential revision.';
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('pull');
     $this->reloadWorkingCopy();
   }
 
   public function getCommitSummary($commit) {
     if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
       return '(The Empty Tree)';
     }
 
     list($summary) = $this->execxLocal(
       'log -n 1 --format=%C %s',
       '%s',
       $commit);
 
     return trim($summary);
   }
 
   public function backoutCommit($commit_hash) {
     $this->execxLocal(
       'revert %s -n --no-edit', $commit_hash);
     $this->reloadWorkingCopy();
     if (!$this->getUncommittedStatus()) {
       throw new ArcanistUsageException(
         "{$commit_hash} has already been reverted.");
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return 'This reverts commit '.$commit_hash.'.';
   }
 
   public function isGitSubversionRepo() {
     return Filesystem::pathExists($this->getPath('.git/svn'));
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     switch ($type) {
       case 'git':
         $matches = null;
         if (preg_match('/^merge-base\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is the merge-base of '{$matches[1]}' and HEAD, as ".
               "specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return trim($merge_base);
           }
         } else if (preg_match('/^branch-unique\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if ($err) {
             return null;
           }
           $merge_base = trim($merge_base);
 
           list($commits) = $this->execxLocal(
             'log --format=%C %s..HEAD --',
             '%H',
             $merge_base);
           $commits = array_filter(explode("\n", $commits));
 
           if (!$commits) {
             return null;
           }
 
           $commits[] = $merge_base;
 
           $head_branch_count = null;
           foreach ($commits as $commit) {
             list($branches) = $this->execxLocal(
               'branch --contains %s',
               $commit);
             $branches = array_filter(explode("\n", $branches));
             if ($head_branch_count === null) {
               // If this is the first commit, it's HEAD. Count how many
               // branches it is on; we want to include commits on the same
               // number of branches. This covers a case where this branch
               // has sub-branches and we're running "arc diff" here again
               // for whatever reason.
               $head_branch_count = count($branches);
             } else if (count($branches) > $head_branch_count) {
               foreach ($branches as $key => $branch) {
                 $branches[$key] = trim($branch, ' *');
               }
               $branches = implode(', ', $branches);
               $this->setBaseCommitExplanation(
                 "it is the first commit between '{$merge_base}' (the ".
                 "merge-base of '{$matches[1]}' and HEAD) which is also ".
                 "contained by another branch ({$branches}).");
               return $commit;
             }
           }
         } else {
           list($err) = $this->execManualLocal(
             'cat-file -t %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return self::GIT_MAGIC_ROOT_COMMIT;
           case 'amended':
             $text = $this->getCommitMessage('HEAD');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 "HEAD has been amended with 'Differential Revision:', ".
                 "as specified by '{$rule}' in your {$source} 'base' ".
                 "configuration.");
               return 'HEAD^';
             }
             break;
           case 'upstream':
             list($err, $upstream) = $this->execManualLocal(
               "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
             if (!$err) {
               $upstream = rtrim($upstream);
               list($upstream_merge_base) = $this->execxLocal(
                 'merge-base %s HEAD',
                 $upstream);
               $upstream_merge_base = rtrim($upstream_merge_base);
               $this->setBaseCommitExplanation(
                 "it is the merge-base of the upstream of the current branch ".
                 "and HEAD, and matched the rule '{$rule}' in your {$source} ".
                 "'base' configuration.");
               return $upstream_merge_base;
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return 'HEAD^';
         }
       default:
         return null;
     }
 
     return null;
   }
 
   public function canStashChanges() {
     return true;
   }
 
   public function stashChanges() {
     $this->execxLocal('stash');
     $this->reloadWorkingCopy();
   }
 
   public function unstashChanges() {
     $this->execxLocal('stash pop');
   }
 
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index 69a89b57..10da4697 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,652 +1,660 @@
 <?php
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @task  status      Path Status
  * @group workingcopy
  */
 abstract class ArcanistRepositoryAPI {
 
   const FLAG_MODIFIED     = 1;
   const FLAG_ADDED        = 2;
   const FLAG_DELETED      = 4;
   const FLAG_UNTRACKED    = 8;
   const FLAG_CONFLICT     = 16;
   const FLAG_MISSING      = 32;
   const FLAG_UNSTAGED     = 64;
   const FLAG_UNCOMMITTED  = 128;
   const FLAG_EXTERNALS    = 256;
 
   // Occurs in SVN when you replace a file with a directory without telling
   // SVN about it.
   const FLAG_OBSTRUCTED   = 512;
 
   // Occurs in SVN when an update was interrupted or failed, e.g. you ^C'd it.
   const FLAG_INCOMPLETE   = 1024;
 
   protected $path;
   protected $diffLinesOfContext = 0x7FFF;
   private $baseCommitExplanation = '???';
   private $configurationManager;
   private $baseCommitArgumentRules;
 
   private $uncommittedStatusCache;
   private $commitRangeStatusCache;
 
   private $symbolicBaseCommit;
   private $resolvedBaseCommit;
 
   abstract public function getSourceControlSystemName();
 
   public function getDiffLinesOfContext() {
     return $this->diffLinesOfContext;
   }
 
   public function setDiffLinesOfContext($lines) {
     $this->diffLinesOfContext = $lines;
     return $this;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->configurationManager->getWorkingCopyIdentity();
   }
 
   public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public static function newAPIFromConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
 
     $working_copy = $configuration_manager->getWorkingCopyIdentity();
 
     if (!$working_copy) {
       throw new Exception(
         pht(
           'Trying to create a RepositoryAPI without a working copy!'));
     }
 
     $root = $working_copy->getProjectRoot();
     switch ($working_copy->getVCSType()) {
       case 'svn':
         $api = new ArcanistSubversionAPI($root);
         break;
       case 'hg':
         $api = new ArcanistMercurialAPI($root);
         break;
       case 'git':
         $api = new ArcanistGitAPI($root);
         break;
       default:
         throw new Exception(
           pht(
             'The current working directory is not part of a working copy for '.
             'a supported version control system (Git, Subversion or '.
             'Mercurial).'));
     }
 
     $api->configurationManager = $configuration_manager;
     return $api;
   }
 
   public function __construct($path) {
     $this->path = $path;
   }
 
   public function getPath($to_file = null) {
     if ($to_file !== null) {
       return $this->path.DIRECTORY_SEPARATOR.
              ltrim($to_file, DIRECTORY_SEPARATOR);
     } else {
       return $this->path.DIRECTORY_SEPARATOR;
     }
   }
 
 
 /* -(  Path Status  )-------------------------------------------------------- */
 
 
   abstract protected function buildUncommittedStatus();
   abstract protected function buildCommitRangeStatus();
 
 
   /**
    * Get a list of uncommitted paths in the working copy that have been changed
    * or are affected by other status effects, like conflicts or untracked
    * files.
    *
    * Convenience methods @{method:getUntrackedChanges},
    * @{method:getUnstagedChanges}, @{method:getUncommittedChanges},
    * @{method:getMergeConflicts}, and @{method:getIncompleteChanges} allow
    * simpler selection of paths in a specific state.
    *
    * This method returns a map of paths to bitmasks with status, using
    * `FLAG_` constants. For example:
    *
    *   array(
    *     'some/uncommitted/file.txt' => ArcanistRepositoryAPI::FLAG_UNSTAGED,
    *   );
    *
    * A file may be in several states. Not all states are possible with all
    * version control systems.
    *
    * @return map<string, bitmask> Map of paths, see above.
    * @task status
    */
   final public function getUncommittedStatus() {
     if ($this->uncommittedStatusCache === null) {
       $status = $this->buildUncommittedStatus();
       ksort($status);
       $this->uncommittedStatusCache = $status;
     }
     return $this->uncommittedStatusCache;
   }
 
 
   /**
    * @task status
    */
   final public function getUntrackedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNTRACKED);
   }
 
 
   /**
    * @task status
    */
   final public function getUnstagedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNSTAGED);
   }
 
 
   /**
    * @task status
    */
   final public function getUncommittedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNCOMMITTED);
   }
 
 
   /**
    * @task status
    */
   final public function getMergeConflicts() {
     return $this->getUncommittedPathsWithMask(self::FLAG_CONFLICT);
   }
 
 
   /**
    * @task status
    */
   final public function getIncompleteChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_INCOMPLETE);
   }
 
 
   /**
    * @task status
    */
   final public function getMissingChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_MISSING);
   }
 
 
   /**
    * @task status
    */
   private function getUncommittedPathsWithMask($mask) {
     $match = array();
     foreach ($this->getUncommittedStatus() as $path => $flags) {
       if ($flags & $mask) {
         $match[] = $path;
       }
     }
     return $match;
   }
 
 
   /**
    * Get a list of paths affected by the commits in the current commit range.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getCommitRangeStatus() {
     if ($this->commitRangeStatusCache === null) {
       $status = $this->buildCommitRangeStatus();
       ksort($status);
       $this->commitRangeStatusCache = $status;
     }
     return $this->commitRangeStatusCache;
   }
 
 
   /**
    * Get a list of paths affected by commits in the current commit range, or
    * uncommitted changes in the working copy. See @{method:getUncommittedStatus}
    * or @{method:getCommitRangeStatus} to retreive smaller parts of the status.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getWorkingCopyStatus() {
     $range_status = $this->getCommitRangeStatus();
     $uncommitted_status = $this->getUncommittedStatus();
 
     $result = new PhutilArrayWithDefaultValue($range_status);
     foreach ($uncommitted_status as $path => $mask) {
       $result[$path] |= $mask;
     }
 
     $result = $result->toArray();
     ksort($result);
     return $result;
   }
 
 
   /**
    * Drops caches after changes to the working copy. By default, some queries
    * against the working copy are cached. They
    *
    * @return this
    * @task status
    */
   final public function reloadWorkingCopy() {
     $this->uncommittedStatusCache = null;
     $this->commitRangeStatusCache = null;
 
     $this->didReloadWorkingCopy();
     $this->reloadCommitRange();
 
     return $this;
   }
 
 
   /**
    * Hook for implementations to dirty working copy caches after the working
    * copy has been updated.
    *
    * @return this
    * @task status
    */
   protected function didReloadWorkingCopy() {
     return;
   }
 
 
   /**
    * Fetches the original file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkOriginalFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getOriginalFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * Fetches the current file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkCurrentFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getCurrentFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * @return Traversable
    */
   abstract public function getAllFiles();
 
   abstract public function getBlame($path);
 
   abstract public function getRawDiffText($path);
   abstract public function getOriginalFileData($path);
   abstract public function getCurrentFileData($path);
   abstract public function getLocalCommitInformation();
   abstract public function getSourceControlBaseRevision();
   abstract public function getCanonicalRevisionName($string);
   abstract public function getBranchName();
   abstract public function getSourceControlPath();
   abstract public function isHistoryDefaultImmutable();
   abstract public function supportsAmend();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function getMetadataPath();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
   abstract public function getRemoteURI();
 
 
   public function getUnderlyingWorkingCopyRevision() {
     return $this->getWorkingCopyRevision();
   }
 
   public function getChangedFiles($since_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAuthor() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function addToCommit(array $paths) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalCommits();
 
   public function doCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function amendCommit($message = null) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllBranches() {
     // TODO: Implement for Mercurial/SVN and make abstract.
     return array();
   }
 
   public function hasLocalCommit($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitMessage($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitSummary($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllLocalChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalBranchMerge();
 
   public function performLocalBranchMerge($branch, $message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getFinalizedRevisionMessage() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function execxLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolvex();
   }
 
   public function execManualLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolve();
   }
 
   public function execFutureLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args);
   }
 
   abstract protected function buildLocalFuture(array $argv);
 
   public function canStashChanges() {
     return false;
   }
 
   public function stashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function unstashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   public function readScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     if (!Filesystem::pathExists($full_path)) {
       return false;
     }
 
     try {
       $result = Filesystem::readFile($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return $result;
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   public function writeScratchFile($path, $data) {
     $dir = $this->getScratchFilePath('');
     if (!$dir) {
       return false;
     }
 
     if (!Filesystem::pathExists($dir)) {
       try {
         Filesystem::createDirectory($dir);
       } catch (Exception $ex) {
         return false;
       }
     }
 
     try {
       Filesystem::writeFile($this->getScratchFilePath($path), $data);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   public function removeScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     try {
       Filesystem::remove($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   public function getReadableScratchFilePath($path) {
     $full_path = $this->getScratchFilePath($path);
     if ($full_path) {
       return Filesystem::readablePath(
         $full_path,
         $this->getPath());
     } else {
       return false;
     }
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   public function getScratchFilePath($path) {
     $new_scratch_path  = Filesystem::resolvePath(
       'arc',
       $this->getMetadataPath());
 
     static $checked = false;
     if (!$checked) {
       $checked = true;
       $old_scratch_path = $this->getPath('.arc');
       // we only want to do the migration once
       // unfortunately, people have checked in .arc directories which
       // means that the old one may get recreated after we delete it
       if (Filesystem::pathExists($old_scratch_path) &&
           !Filesystem::pathExists($new_scratch_path)) {
         Filesystem::createDirectory($new_scratch_path);
         $existing_files = Filesystem::listDirectory($old_scratch_path, true);
         foreach ($existing_files as $file) {
           $new_path = Filesystem::resolvePath($file, $new_scratch_path);
           $old_path = Filesystem::resolvePath($file, $old_scratch_path);
           Filesystem::writeFile(
             $new_path,
             Filesystem::readFile($old_path));
         }
         Filesystem::remove($old_scratch_path);
       }
     }
     return Filesystem::resolvePath($path, $new_scratch_path);
   }
 
 
 /* -(  Base Commits  )------------------------------------------------------- */
 
   abstract public function supportsCommitRanges();
 
   final public function setBaseCommit($symbolic_commit) {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     $this->symbolicBaseCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
+  public function setHeadCommit($symbolic_commit) {
+    throw new ArcanistCapabilityNotSupportedException($this);
+  }
+
   final public function getBaseCommit() {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     if ($this->resolvedBaseCommit === null) {
       $commit = $this->buildBaseCommit($this->symbolicBaseCommit);
       $this->resolvedBaseCommit = $commit;
     }
 
     return $this->resolvedBaseCommit;
   }
 
+  public function getHeadCommit() {
+    throw new ArcanistCapabilityNotSupportedException($this);
+  }
+
   final public function reloadCommitRange() {
     $this->resolvedBaseCommit = null;
     $this->baseCommitExplanation = null;
 
     $this->didReloadCommitRange();
 
     return $this;
   }
 
   protected function didReloadCommitRange() {
     return;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getBaseCommitExplanation() {
     return $this->baseCommitExplanation;
   }
 
   public function setBaseCommitExplanation($explanation) {
     $this->baseCommitExplanation = $explanation;
     return $this;
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     return null;
   }
 
   public function setBaseCommitArgumentRules($base_commit_argument_rules) {
     $this->baseCommitArgumentRules = $base_commit_argument_rules;
     return $this;
   }
 
   public function getBaseCommitArgumentRules() {
     return $this->baseCommitArgumentRules;
   }
 
   public function resolveBaseCommit() {
     $base_commit_rules = array(
       'runtime' => $this->getBaseCommitArgumentRules(),
       'local'   => '',
       'project' => '',
       'user'    => '',
       'system'  => '',
     );
     $all_sources = $this->configurationManager->getConfigFromAllSources('base');
 
     $base_commit_rules = $all_sources + $base_commit_rules;
 
     $parser = new ArcanistBaseCommitParser($this);
     $commit = $parser->resolveBaseCommit($base_commit_rules);
 
     return $commit;
   }
 
   public function getRepositoryUUID() {
     return null;
   }
 
 }
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index 34695d24..fead0459 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,2596 +1,2625 @@
 <?php
 
 /**
  * Sends changes from your working copy to Differential for code review.
  *
  * @task lintunit   Lint and Unit Tests
  * @task message    Commit and Update Messages
  * @task diffspec   Diff Specification
  * @task diffprop   Diff Properties
  *
  * @group workflow
  */
 final class ArcanistDiffWorkflow extends ArcanistBaseWorkflow {
 
   private $console;
   private $hasWarnedExternals = false;
   private $unresolvedLint;
   private $excuses = array('lint' => null, 'unit' => null);
   private $testResults;
   private $diffID;
   private $revisionID;
   private $postponedLinters;
   private $haveUncommittedChanges = false;
   private $diffPropertyFutures = array();
   private $commitMessageFromRevision;
 
   public function getWorkflowName() {
     return 'diff';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **diff** [__paths__] (svn)
       **diff** [__commit__] (git, hg)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Generate a Differential diff or revision from local changes.
 
           Under git and mercurial, you can specify a commit (like __HEAD^^^__
           or __master__) and Differential will generate a diff against the
           merge base of that commit and your current working directory parent.
 
           Under svn, you can choose to include only some of the modified files
           in the working copy in the diff by specifying their paths. If you
           omit paths, all changes are included in the diff.
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return !$this->isRawDiffSource();
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     if (!$this->isRawDiffSource()) {
       return true;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return true;
     }
 
     return false;
   }
 
   public function getDiffID() {
     return $this->diffID;
   }
 
   public function getArguments() {
     $arguments = array(
       'message' => array(
         'short'       => 'm',
         'param'       => 'message',
         'help' =>
           'When updating a revision, use the specified message instead of '.
           'prompting.',
       ),
       'message-file' => array(
         'short' => 'F',
         'param' => 'file',
         'paramtype' => 'file',
         'help' => 'When creating a revision, read revision information '.
                   'from this file.',
       ),
       'use-commit-message' => array(
         'supports' => array(
           'git',
           // TODO: Support mercurial.
         ),
         'short' => 'C',
         'param' => 'commit',
         'help' => 'Read revision information from a specific commit.',
         'conflicts' => array(
           'only'    => null,
           'preview' => null,
           'update'  => null,
         ),
       ),
       'edit' => array(
         'supports'    => array(
           'git',
           'hg',
         ),
         'nosupport'   => array(
           'svn' => 'Edit revisions via the web interface when using SVN.',
         ),
         'help' =>
           'When updating a revision under git, edit revision information '.
           'before updating.',
       ),
       'raw' => array(
         'help' =>
           'Read diff from stdin, not from the working copy. This disables '.
           'many Arcanist/Phabricator features which depend on having access '.
           'to the working copy.',
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw disables lint.',
           'never-apply-patches' => '--raw disables lint.',
           'advice'              => '--raw disables lint.',
           'lintall'             => '--raw disables lint.',
 
           'create'              => '--raw and --create both need stdin. '.
                                    'Use --raw-command.',
           'edit'                => '--raw and --edit both need stdin. '.
                                    'Use --raw-command.',
           'raw-command'         => null,
         ),
       ),
       'raw-command' => array(
         'param' => 'command',
         'help' =>
           'Generate diff by executing a specified command, not from the '.
           'working copy. This disables many Arcanist/Phabricator features '.
           'which depend on having access to the working copy.',
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw-command disables lint.',
           'never-apply-patches' => '--raw-command disables lint.',
           'advice'              => '--raw-command disables lint.',
           'lintall'             => '--raw-command disables lint.',
         ),
       ),
       'create' => array(
         'help' => 'Always create a new revision.',
         'conflicts' => array(
           'edit'    => '--create can not be used with --edit.',
           'only'    => '--create can not be used with --only.',
           'preview' => '--create can not be used with --preview.',
           'update'  => '--create can not be used with --update.',
         ),
       ),
       'update' => array(
         'param' => 'revision_id',
         'help'  => 'Always update a specific revision.',
       ),
       'nounit' => array(
         'help' =>
           'Do not run unit tests.',
       ),
       'nolint' => array(
         'help' =>
           'Do not run lint.',
         'conflicts' => array(
           'lintall'   => '--nolint suppresses lint.',
           'advice'    => '--nolint suppresses lint.',
           'apply-patches' => '--nolint suppresses lint.',
           'never-apply-patches' => '--nolint suppresses lint.',
         ),
       ),
       'only' => array(
         'help' =>
           'Only generate a diff, without running lint, unit tests, or other '.
           'auxiliary steps. See also --preview.',
         'conflicts' => array(
           'preview'   => null,
           'message'   => '--only does not affect revisions.',
           'edit'      => '--only does not affect revisions.',
           'lintall'   => '--only suppresses lint.',
           'advice'    => '--only suppresses lint.',
           'apply-patches' => '--only suppresses lint.',
           'never-apply-patches' => '--only suppresses lint.',
         ),
       ),
       'preview' => array(
         'help' =>
           'Instead of creating or updating a revision, only create a diff, '.
           'which you may later attach to a revision. This still runs lint '.
           'unit tests. See also --only.',
         'conflicts' => array(
           'only'      => null,
           'edit'      => '--preview does affect revisions.',
           'message'   => '--preview does not update any revision.',
         ),
       ),
       'plan-changes' => array(
         'help' =>
           'Create or update a revision without requesting a code review.',
         'conflicts' => array(
           'only'     => '--only does not affect revisions.',
           'preview'  => '--preview does not affect revisions.',
         ),
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           'Attempt to convert non UTF-8 hunks into specified encoding.',
       ),
       'allow-untracked' => array(
         'help' =>
           'Skip checks for untracked files in the working copy.',
       ),
       'excuse' => array(
         'param' => 'excuse',
         'help' => 'Provide a prepared in advance excuse for any lints/tests'.
           ' shall they fail.',
       ),
       'less-context' => array(
         'help' =>
           "Normally, files are diffed with full context: the entire file is ".
           "sent to Differential so reviewers can 'show more' and see it. If ".
           "you are making changes to very large files with tens of thousands ".
           "of lines, this may not work well. With this flag, a diff will ".
           "be created that has only a few lines of context.",
       ),
       'lintall' => array(
         'help' =>
           'Raise all lint warnings, not just those on lines you changed.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'advice' => array(
         'help' =>
           'Require excuse for lint advice in addition to lint warnings and '.
           'errors.',
       ),
       'only-new' => array(
         'param' => 'bool',
         'help' =>
           'Display only lint messages not present in the original code.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'apply-patches' => array(
         'help' =>
           'Apply patches suggested by lint to the working copy without '.
           'prompting.',
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => 'Never apply patches suggested by lint.',
         'conflicts' => array(
           'apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-all' => array(
         'help' =>
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-autofixes' => array(
         'help' =>
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'add-all' => array(
         'short' => 'a',
         'help' =>
           'Automatically add all untracked, unstaged and uncommitted files to '.
           'the commit.',
       ),
       'json' => array(
         'help' =>
           'Emit machine-readable JSON. EXPERIMENTAL! Probably does not work!',
       ),
       'no-amend' => array(
         'help' => 'Never amend commits in the working copy with lint patches.',
       ),
       'uncommitted' => array(
         'help' => 'Suppress warning about uncommitted changes.',
         'supports' => array(
           'hg',
         ),
       ),
       'verbatim' => array(
         'help' => 'When creating a revision, try to use the working copy '.
                   'commit message verbatim, without prompting to edit it. '.
                   'When updating a revision, update some fields from the '.
                   'local commit message.',
         'supports' => array(
           'hg',
           'git',
         ),
         'conflicts' => array(
           'use-commit-message'  => true,
           'update'              => true,
           'only'                => true,
           'preview'             => true,
           'raw'                 => true,
           'raw-command'         => true,
           'message-file'        => true,
         ),
       ),
       'reviewers' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add reviewers.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'cc' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add CCs.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'skip-binaries' => array(
         'help'  => 'Do not upload binaries (like images).',
       ),
       'ignore-unsound-tests' => array(
         'help'  => 'Ignore unsound test failures without prompting.',
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => 'Additional rules for determining base revision.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
       'no-diff' => array(
         'help' => 'Only run lint and unit tests. Intended for internal use.',
       ),
       'background' => array(
         'param' => 'bool',
         'help' =>
           'Run lint and unit tests on background. '.
           '"0" to disable, "1" to enable (default).',
       ),
       'cache' => array(
         'param' => 'bool',
         'help' => '0 to disable lint cache, 1 to enable (default).',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'coverage' => array(
         'help' => 'Always enable coverage information.',
         'conflicts' => array(
           'no-coverage' => null,
         ),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'no-coverage' => array(
         'help' => 'Always disable coverage information.',
         'passthru' => array(
           'unit' => true,
         ),
       ),
       '*' => 'paths',
+      'head' => array(
+        'param' => 'commit',
+        'help' => "specify the head commit.\n".
+          "This disables many Arcanist/Phabricator features which depend on ".
+          "having access to the working copy.",
+        'supports' => array('git'),
+        'conflicts' => array(
+          'lintall'   => '--head suppresses lint.',
+          'advice'    => '--head suppresses lint.',
+        ),
+
+      )
     );
 
     if (phutil_is_windows()) {
       unset($arguments['background']);
     }
 
     return $arguments;
   }
 
   public function isRawDiffSource() {
     return $this->getArgument('raw') || $this->getArgument('raw-command');
   }
 
   public function run() {
     $this->console = PhutilConsole::getConsole();
 
     $this->runRepositoryAPISetup();
 
     if ($this->getArgument('no-diff')) {
       $this->removeScratchFile('diff-result.json');
       $data = $this->runLintUnit();
       $this->writeScratchJSONFile('diff-result.json', $data);
       return 0;
     }
 
     $this->runDiffSetupBasics();
 
     $background = $this->getArgument('background', true);
     if ($this->isRawDiffSource() || phutil_is_windows()) {
       $background = false;
     }
 
     if ($background) {
       $argv = $this->getPassedArguments();
       if (!PhutilConsoleFormatter::getDisableANSI()) {
         array_unshift($argv, '--ansi');
       }
 
-      if ($this->getRepositoryAPI()->supportsCommitRanges()) {
-        $this->getRepositoryAPI()->getBaseCommit();
+      $repo = $this->getRepositoryAPI();
+      $head_commit = $this->getArgument('head');
+      $range_supported = $repo->supportsCommitRanges();
+      if ($head_commit) {
+        if (!$range_supported) {
+          throw new ArcanistUsageException('Ranged are not supported');
+        }
+
+        $repo->setHeadCommit($head_commit);
+      }
+
+      if ($range_supported) {
+        $repo->getBaseCommit();
       }
 
       $script = phutil_get_library_root('arcanist').'/../scripts/arcanist.php';
       if ($argv) {
         $lint_unit = new ExecFuture(
           'php %s --recon diff --no-diff %Ls',
           $script,
           $argv);
       } else {
         $lint_unit = new ExecFuture(
           'php %s --recon diff --no-diff',
           $script);
       }
 
       $lint_unit->write('', true);
       $lint_unit->start();
     }
 
     $commit_message = $this->buildCommitMessage();
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDBUILDMESSAGE,
       array(
         'message' => $commit_message,
       ));
 
     if (!$this->shouldOnlyCreateDiff()) {
       $revision = $this->buildRevisionFromCommitMessage($commit_message);
     }
 
     if ($background) {
       $server = new PhutilConsoleServer();
       $server->addExecFutureClient($lint_unit);
       $server->setHandler(array($this, 'handleServerMessage'));
       $server->run();
 
       list($err) = $lint_unit->resolve();
       $data = $this->readScratchJSONFile('diff-result.json');
       if ($err || !$data) {
         throw new Exception(
           'Unable to read results from background linting and unit testing. '.
           'You can try running arc diff again with --background 0');
       }
     } else {
       $server = $this->console->getServer();
       $server->setHandler(array($this, 'handleServerMessage'));
       $data = $this->runLintUnit();
     }
     $lint_result = $data['lintResult'];
     $this->unresolvedLint = $data['unresolvedLint'];
     $this->postponedLinters = $data['postponedLinters'];
     $unit_result = $data['unitResult'];
     $this->testResults = $data['testResults'];
 
     if ($this->getArgument('nolint')) {
       $this->excuses['lint'] = $this->getSkipExcuse(
         'Provide explanation for skipping lint or press Enter to abort:',
         'lint-excuses');
     }
 
     if ($this->getArgument('nounit')) {
       $this->excuses['unit'] = $this->getSkipExcuse(
         'Provide explanation for skipping unit tests or press Enter to abort:',
         'unit-excuses');
     }
 
     $changes = $this->generateChanges();
     if (!$changes) {
       throw new ArcanistUsageException(
         'There are no changes to generate a diff from!');
     }
 
     $diff_spec = array(
       'changes' => mpull($changes, 'toDictionary'),
       'lintStatus' => $this->getLintStatus($lint_result),
       'unitStatus' => $this->getUnitStatus($unit_result),
     ) + $this->buildDiffSpecification();
 
     $conduit = $this->getConduit();
     $diff_info = $conduit->callMethodSynchronous(
       'differential.creatediff',
       $diff_spec);
 
     $this->diffID = $diff_info['diffid'];
 
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WASCREATED,
       array(
         'diffID' => $diff_info['diffid'],
         'lintResult' => $lint_result,
         'unitResult' => $unit_result,
       ));
 
     $this->updateLintDiffProperty();
     $this->updateUnitDiffProperty();
     $this->updateLocalDiffProperty();
     $this->resolveDiffPropertyUpdates();
 
     $output_json = $this->getArgument('json');
 
     if ($this->shouldOnlyCreateDiff()) {
       if (!$output_json) {
         echo phutil_console_format(
           "Created a new Differential diff:\n".
           "        **Diff URI:** __%s__\n\n",
           $diff_info['uri']);
       } else {
         $human = ob_get_clean();
         echo json_encode(array(
           'diffURI' => $diff_info['uri'],
           'diffID'  => $this->getDiffID(),
           'human'   => $human,
         ))."\n";
         ob_start();
       }
     } else {
       $revision['diffid'] = $this->getDiffID();
 
       if ($commit_message->getRevisionID()) {
         $result = $conduit->callMethodSynchronous(
           'differential.updaterevision',
           $revision);
 
         foreach (array('edit-messages.json', 'update-messages.json') as $file) {
           $messages = $this->readScratchJSONFile($file);
           unset($messages[$revision['id']]);
           $this->writeScratchJSONFile($file, $messages);
         }
 
         echo "Updated an existing Differential revision:\n";
       } else {
         $revision = $this->dispatchWillCreateRevisionEvent($revision);
 
         $result = $conduit->callMethodSynchronous(
           'differential.createrevision',
           $revision);
 
         $revised_message = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $result['revisionid'],
           ));
 
         if ($this->shouldAmend()) {
           $repository_api = $this->getRepositoryAPI();
           if ($repository_api->supportsAmend()) {
             echo "Updating commit message...\n";
             $repository_api->amendCommit($revised_message);
           } else {
             echo 'Commit message was not amended. Amending commit message is '.
                  'only supported in git and hg (version 2.2 or newer)';
           }
         }
 
         echo "Created a new Differential revision:\n";
       }
 
       $uri = $result['uri'];
       echo phutil_console_format(
         "        **Revision URI:** __%s__\n\n",
         $uri);
 
       if ($this->getArgument('plan-changes')) {
         $conduit->callMethodSynchronous(
           'differential.createcomment',
           array(
             'revision_id' => $result['revisionid'],
             'action' => 'rethink',
           ));
         echo "Planned changes to the revision.\n";
       }
     }
 
     echo "Included changes:\n";
     foreach ($changes as $change) {
       echo '  '.$change->renderTextSummary()."\n";
     }
 
     if ($output_json) {
       ob_get_clean();
     }
 
     $this->removeScratchFile('create-message');
 
     return 0;
   }
 
   private function runRepositoryAPISetup() {
     if (!$this->requiresRepositoryAPI()) {
       return;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($this->getArgument('less-context')) {
       $repository_api->setDiffLinesOfContext(3);
     }
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
     if ($repository_api->supportsCommitRanges()) {
       $this->parseBaseCommitArgument($this->getArgument('paths'));
     }
   }
 
   private function runDiffSetupBasics() {
     $output_json = $this->getArgument('json');
     if ($output_json) {
       // TODO: We should move this to a higher-level and put an indirection
       // layer between echoing stuff and stdout.
       ob_start();
     }
 
     if ($this->requiresWorkingCopy()) {
       $repository_api = $this->getRepositoryAPI();
       try {
         if ($this->getArgument('add-all')) {
           $this->setCommitMode(self::COMMIT_ENABLE);
         } else if ($this->getArgument('uncommitted')) {
           $this->setCommitMode(self::COMMIT_DISABLE);
         } else {
           $this->setCommitMode(self::COMMIT_ALLOW);
         }
         if ($repository_api instanceof ArcanistSubversionAPI) {
           $repository_api->limitStatusToPaths($this->getArgument('paths'));
         }
-        $this->requireCleanWorkingCopy();
+        if (!$this->getArgument('head')) {
+          $this->requireCleanWorkingCopy();
+        }
       } catch (ArcanistUncommittedChangesException $ex) {
         if ($repository_api instanceof ArcanistMercurialAPI) {
           $use_dirty_changes = false;
           if ($this->getArgument('uncommitted')) {
             // OK.
           } else {
             $ok = phutil_console_confirm(
               "You have uncommitted changes in your working copy. You can ".
               "include them in the diff, or abort and deal with them. (Use ".
               "'--uncommitted' to include them and skip this prompt.) ".
               "Do you want to include uncommitted changes in the diff?");
             if (!$ok) {
               throw $ex;
             }
           }
 
           $this->haveUncommittedChanges = true;
         } else {
           throw $ex;
         }
       }
     }
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDCOLLECTCHANGES,
       array());
   }
 
   private function buildRevisionFromCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
 
     $conduit = $this->getConduit();
 
     $revision_id = $message->getRevisionID();
     $revision = array(
       'fields' => $message->getFields(),
     );
 
     if ($revision_id) {
 
       // With '--verbatim', pass the (possibly modified) local fields. This
       // allows the user to edit some fields (like "title" and "summary")
       // locally without '--edit' and have changes automatically synchronized.
       // Without '--verbatim', we do not update the revision to reflect local
       // commit message changes.
       if ($this->getArgument('verbatim')) {
         $use_fields = $message->getFields();
       } else {
         $use_fields = array();
       }
 
       $should_edit = $this->getArgument('edit');
       $edit_messages = $this->readScratchJSONFile('edit-messages.json');
       $remote_corpus = idx($edit_messages, $revision_id);
 
       if (!$should_edit || !$remote_corpus || $use_fields) {
         if ($this->commitMessageFromRevision) {
           $remote_corpus = $this->commitMessageFromRevision;
         } else {
           $remote_corpus = $conduit->callMethodSynchronous(
             'differential.getcommitmessage',
             array(
               'revision_id' => $revision_id,
               'edit'        => 'edit',
               'fields'      => $use_fields,
             ));
         }
       }
 
       if ($should_edit) {
         $edited = $this->newInteractiveEditor($remote_corpus)
           ->setName('differential-edit-revision-info')
           ->editInteractively();
         if ($edited != $remote_corpus) {
           $remote_corpus = $edited;
           $edit_messages[$revision_id] = $remote_corpus;
           $this->writeScratchJSONFile('edit-messages.json', $edit_messages);
         }
       }
 
       if ($this->commitMessageFromRevision == $remote_corpus) {
         $new_message = $message;
       } else {
         $remote_corpus = ArcanistCommentRemover::removeComments(
           $remote_corpus);
         $new_message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $remote_corpus);
         $new_message->pullDataFromConduit($conduit);
       }
 
       $revision['fields'] = $new_message->getFields();
 
       $revision['id'] = $revision_id;
       $this->revisionID = $revision_id;
 
       $revision['message'] = $this->getArgument('message');
       if (!strlen($revision['message'])) {
         $update_messages = $this->readScratchJSONFile('update-messages.json');
 
         $update_messages[$revision_id] = $this->getUpdateMessage(
           $revision['fields'],
           idx($update_messages, $revision_id));
 
         $revision['message'] = ArcanistCommentRemover::removeComments(
           $update_messages[$revision_id]);
         if (!strlen(trim($revision['message']))) {
           throw new ArcanistUserAbortException();
         }
 
         $this->writeScratchJSONFile('update-messages.json', $update_messages);
       }
     }
 
     return $revision;
   }
 
   protected function shouldOnlyCreateDiff() {
 
     if ($this->getArgument('create')) {
       return false;
     }
 
     if ($this->getArgument('update')) {
       return false;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return false;
     }
 
     if ($this->isRawDiffSource()) {
       return true;
     }
 
     return $this->getArgument('preview') ||
            $this->getArgument('only');
   }
 
   private function generateAffectedPaths() {
     if ($this->isRawDiffSource()) {
       return array();
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $file_list = new FileList($this->getArgument('paths', array()));
       $paths = $repository_api->getSVNStatus($externals = true);
       foreach ($paths as $path => $mask) {
         if (!$file_list->contains($repository_api->getPath($path), true)) {
           unset($paths[$path]);
         }
       }
 
       $warn_externals = array();
       foreach ($paths as $path => $mask) {
         $any_mod = ($mask & ArcanistRepositoryAPI::FLAG_ADDED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_MODIFIED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_DELETED);
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($paths[$path]);
           if ($any_mod) {
             $warn_externals[] = $path;
           }
         }
       }
 
       if ($warn_externals && !$this->hasWarnedExternals) {
         echo phutil_console_format(
           "The working copy includes changes to 'svn:externals' paths. These ".
           "changes will not be included in the diff because SVN can not ".
           "commit 'svn:externals' changes alongside normal changes.".
           "\n\n".
           "Modified 'svn:externals' files:".
           "\n\n".
           phutil_console_wrap(implode("\n", $warn_externals), 8));
         $prompt = 'Generate a diff (with just local changes) anyway?';
         if (!phutil_console_confirm($prompt)) {
           throw new ArcanistUserAbortException();
         } else {
           $this->hasWarnedExternals = true;
         }
       }
 
     } else {
       $paths = $repository_api->getWorkingCopyStatus();
     }
 
     foreach ($paths as $path => $mask) {
       if ($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
         unset($paths[$path]);
       }
     }
 
     return $paths;
   }
 
 
   protected function generateChanges() {
     $parser = $this->newDiffParser();
 
     $is_raw = $this->isRawDiffSource();
     if ($is_raw) {
 
       if ($this->getArgument('raw')) {
         fwrite(STDERR, "Reading diff from stdin...\n");
         $raw_diff = file_get_contents('php://stdin');
       } else if ($this->getArgument('raw-command')) {
         list($raw_diff) = execx('%C', $this->getArgument('raw-command'));
       } else {
         throw new Exception('Unknown raw diff source.');
       }
 
       $changes = $parser->parseDiff($raw_diff);
       foreach ($changes as $key => $change) {
         // Remove "message" changes, e.g. from "git show".
         if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
           unset($changes[$key]);
         }
       }
       return $changes;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $paths = $this->generateAffectedPaths();
       $this->primeSubversionWorkingCopyData($paths);
 
       // Check to make sure the user is diffing from a consistent base revision.
       // This is mostly just an abuse sanity check because it's silly to do this
       // and makes the code more difficult to effectively review, but it also
       // affects patches and makes them nonportable.
       $bases = $repository_api->getSVNBaseRevisions();
 
       // Remove all files with baserev "0"; these files are new.
       foreach ($bases as $path => $baserev) {
         if ($bases[$path] <= 0) {
           unset($bases[$path]);
         }
       }
 
       if ($bases) {
         $rev = reset($bases);
 
         $revlist = array();
         foreach ($bases as $path => $baserev) {
           $revlist[] = "    Revision {$baserev}, {$path}";
         }
         $revlist = implode("\n", $revlist);
 
         foreach ($bases as $path => $baserev) {
           if ($baserev !== $rev) {
             throw new ArcanistUsageException(
               "Base revisions of changed paths are mismatched. Update all ".
               "paths to the same base revision before creating a diff: ".
               "\n\n".
               $revlist);
           }
         }
 
         // If you have a change which affects several files, all of which are
         // at a consistent base revision, treat that revision as the effective
         // base revision. The use case here is that you made a change to some
         // file, which updates it to HEAD, but want to be able to change it
         // again without updating the entire working copy. This is a little
         // sketchy but it arises in Facebook Ops workflows with config files and
         // doesn't have any real material tradeoffs (e.g., these patches are
         // perfectly applyable).
         $repository_api->overrideSVNBaseRevisionNumber($rev);
       }
 
       $changes = $parser->parseSubversionDiff(
         $repository_api,
         $paths);
     } else if ($repository_api instanceof ArcanistGitAPI) {
-      $diff = $repository_api->getFullGitDiff();
+      $diff = $repository_api->getFullGitDiff(
+        $repository_api->getBaseCommit(),
+        $repository_api->getHeadCommit());
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           'No changes found. (Did you specify the wrong commit range?)');
       }
       $changes = $parser->parseDiff($diff);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $diff = $repository_api->getFullMercurialDiff();
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           'No changes found. (Did you specify the wrong commit range?)');
       }
       $changes = $parser->parseDiff($diff);
     } else {
       throw new Exception('Repository API is not supported.');
     }
 
     if (count($changes) > 250) {
       $count = number_format(count($changes));
       $link =
         'http://www.phabricator.com/docs/phabricator/article/'.
         'Differential_User_Guide_Large_Changes.html';
       $message =
         "This diff has a very large number of changes ({$count}). ".
         "Differential works best for changes which will receive detailed ".
         "human review, and not as well for large automated changes or ".
         "bulk checkins. See {$link} for information about reviewing big ".
         "checkins. Continue anyway?";
       if (!phutil_console_confirm($message)) {
         throw new ArcanistUsageException(
           'Aborted generation of gigantic diff.');
       }
     }
 
     $limit = 1024 * 1024 * 4;
     foreach ($changes as $change) {
       $size = 0;
       foreach ($change->getHunks() as $hunk) {
         $size += strlen($hunk->getCorpus());
       }
       if ($size > $limit) {
         $file_name = $change->getCurrentPath();
         $change_size = number_format($size);
         $byte_warning =
           "Diff for '{$file_name}' with context is {$change_size} bytes in ".
           "length. Generally, source changes should not be this large.";
         if (!$this->getArgument('less-context')) {
           $byte_warning .=
             " If this file is a huge text file, try using the ".
             "'--less-context' flag.";
         }
         if ($repository_api instanceof ArcanistSubversionAPI) {
           throw new ArcanistUsageException(
             "{$byte_warning} If the file is not a text file, mark it as ".
             "binary with:".
             "\n\n".
             "  $ svn propset svn:mime-type application/octet-stream <filename>".
             "\n");
         } else {
           $confirm =
             "{$byte_warning} If the file is not a text file, you can ".
             "mark it 'binary'. Mark this file as 'binary' and continue?";
           if (phutil_console_confirm($confirm)) {
             $change->convertToBinaryChange($repository_api);
           } else {
             throw new ArcanistUsageException(
               'Aborted generation of gigantic diff.');
           }
         }
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
 
     $utf8_problems = array();
     foreach ($changes as $change) {
       foreach ($change->getHunks() as $hunk) {
         $corpus = $hunk->getCorpus();
         if (!phutil_is_utf8($corpus)) {
 
           // If this corpus is heuristically binary, don't try to convert it.
           // mb_check_encoding() and mb_convert_encoding() are both very very
           // liberal about what they're willing to process.
           $is_binary = ArcanistDiffUtils::isHeuristicBinaryFile($corpus);
           if (!$is_binary) {
 
             if (!$try_encoding) {
               try {
                 $try_encoding = $this->getRepositoryEncoding();
               } catch (ConduitClientException $e) {
                 if ($e->getErrorCode() == 'ERR-BAD-ARCANIST-PROJECT') {
                   echo phutil_console_wrap(
                     "Lookup of encoding in arcanist project failed\n".
                     $e->getMessage());
                 } else {
                   throw $e;
                 }
               }
             }
 
             if ($try_encoding) {
               $corpus = phutil_utf8_convert($corpus, 'UTF-8', $try_encoding);
               $name = $change->getCurrentPath();
               if (phutil_is_utf8($corpus)) {
                 $this->writeStatusMessage(
                   "Converted a '{$name}' hunk from '{$try_encoding}' ".
                   "to UTF-8.\n");
                 $hunk->setCorpus($corpus);
                 continue;
               }
             }
           }
           $utf8_problems[] = $change;
           break;
         }
       }
     }
 
     // If there are non-binary files which aren't valid UTF-8, warn the user
     // and treat them as binary changes. See D327 for discussion of why Arcanist
     // has this behavior.
     if ($utf8_problems) {
       $utf8_warning =
         pht(
           'This diff includes file(s) which are not valid UTF-8 (they contain '.
             'invalid byte sequences). You can either stop this workflow and '.
             'fix these files, or continue. If you continue, these files will '.
             'be marked as binary.',
           count($utf8_problems))."\n\n".
         "You can learn more about how Phabricator handles character encodings ".
         "(and how to configure encoding settings and detect and correct ".
         "encoding problems) by reading 'User Guide: UTF-8 and Character ".
         "Encoding' in the Phabricator documentation.\n\n".
         "    ".pht('AFFECTED FILE(S)', count($utf8_problems))."\n";
       $confirm = pht(
         'Do you want to mark these files as binary and continue?',
         count($utf8_problems));
 
       echo phutil_console_format("**Invalid Content Encoding (Non-UTF8)**\n");
       echo phutil_console_wrap($utf8_warning);
 
       $file_list = mpull($utf8_problems, 'getCurrentPath');
       $file_list = '    '.implode("\n    ", $file_list);
       echo $file_list;
 
       if (!phutil_console_confirm($confirm, $default_no = false)) {
         throw new ArcanistUsageException('Aborted workflow to fix UTF-8.');
       } else {
         foreach ($utf8_problems as $change) {
           $change->convertToBinaryChange($repository_api);
         }
       }
     }
 
     $this->uploadFilesForChanges($changes);
 
     return $changes;
   }
 
   private function getGitParentLogInfo() {
     $info = array(
       'parent'        => null,
       'base_revision' => null,
       'base_path'     => null,
       'uuid'          => null,
     );
 
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $history_messages = $repository_api->getGitHistoryLog();
     if (!$history_messages) {
       // This can occur on the initial commit.
       return $info;
     }
     $history_messages = $parser->parseDiff($history_messages);
 
     foreach ($history_messages as $key => $change) {
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $change->getMetadata('message'));
         if ($message->getRevisionID() && $info['parent'] === null) {
           $info['parent'] = $message->getRevisionID();
         }
         if ($message->getGitSVNBaseRevision() &&
             $info['base_revision'] === null) {
           $info['base_revision'] = $message->getGitSVNBaseRevision();
           $info['base_path']     = $message->getGitSVNBasePath();
         }
         if ($message->getGitSVNUUID()) {
           $info['uuid'] = $message->getGitSVNUUID();
         }
         if ($info['parent'] && $info['base_revision']) {
           break;
         }
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         // Ignore.
       } catch (ArcanistUsageException $ex) {
         // Ignore an invalid Differential Revision field in the parent commit
       }
     }
 
     return $info;
   }
 
   protected function primeSubversionWorkingCopyData($paths) {
     $repository_api = $this->getRepositoryAPI();
 
     $futures = array();
     $targets = array();
     foreach ($paths as $path => $mask) {
       $futures[] = $repository_api->buildDiffFuture($path);
       $targets[] = array('command' => 'diff', 'path' => $path);
       $futures[] = $repository_api->buildInfoFuture($path);
       $targets[] = array('command' => 'info', 'path' => $path);
     }
 
     foreach (Futures($futures)->limit(8) as $key => $future) {
       $target = $targets[$key];
       if ($target['command'] == 'diff') {
         $repository_api->primeSVNDiffResult(
           $target['path'],
           $future->resolve());
       } else {
         $repository_api->primeSVNInfoResult(
           $target['path'],
           $future->resolve());
       }
     }
   }
 
   private function shouldAmend() {
     if ($this->isRawDiffSource()) {
       return false;
     }
 
     if ($this->haveUncommittedChanges) {
       return false;
     }
 
     if ($this->getArgument('no-amend')) {
       return false;
     }
 
     // Run this last: with --raw or --raw-command, we won't have a repository
     // API.
     if ($this->isHistoryImmutable()) {
       return false;
     }
 
     return true;
   }
 
 
 /* -(  Lint and Unit Tests  )------------------------------------------------ */
 
 
   /**
    * @task lintunit
    */
   private function runLintUnit() {
     $lint_result = $this->runLint();
     $unit_result = $this->runUnit();
     return array(
       'lintResult' => $lint_result,
       'unresolvedLint' => $this->unresolvedLint,
       'postponedLinters' => $this->postponedLinters,
       'unitResult' => $unit_result,
       'testResults' => $this->testResults,
     );
   }
 
 
   /**
    * @task lintunit
    */
   private function runLint() {
     if ($this->getArgument('nolint') ||
         $this->getArgument('only') ||
-        $this->isRawDiffSource()) {
+        $this->isRawDiffSource() ||
+        $this->getArgument('head')) {
       return ArcanistLintWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("Linting...\n");
     try {
       $argv = $this->getPassthruArgumentsAsArgv('lint');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
 
       $lint_workflow = $this->buildChildWorkflow('lint', $argv);
 
       if ($this->shouldAmend()) {
         // TODO: We should offer to create a checkpoint commit.
         $lint_workflow->setShouldAmendChanges(true);
       }
 
       $lint_result = $lint_workflow->run();
 
       switch ($lint_result) {
         case ArcanistLintWorkflow::RESULT_OKAY:
           if ($this->getArgument('advice') &&
               $lint_workflow->getUnresolvedMessages()) {
             $this->getErrorExcuse(
               'lint',
               'Lint issued unresolved advice.',
               'lint-excuses');
           } else {
             $this->console->writeOut(
               "<bg:green>** LINT OKAY **</bg> No lint problems.\n");
           }
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->getErrorExcuse(
             'lint',
             'Lint issued unresolved warnings.',
             'lint-excuses');
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           $this->console->writeOut(
             "<bg:red>** LINT ERRORS **</bg> Lint raised errors!\n");
           $this->getErrorExcuse(
             'lint',
             'Lint issued unresolved errors!',
             'lint-excuses');
           break;
         case ArcanistLintWorkflow::RESULT_POSTPONED:
           $this->console->writeOut(
             "<bg:yellow>** LINT POSTPONED **</bg> ".
             "Lint results are postponed.\n");
           break;
       }
 
       $this->unresolvedLint = array();
       foreach ($lint_workflow->getUnresolvedMessages() as $message) {
         $this->unresolvedLint[] = $message->toDictionary();
       }
 
       $this->postponedLinters = $lint_workflow->getPostponedLinters();
 
       return $lint_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut("No lint engine configured for this project.\n");
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut($ex->getMessage()."\n");
     }
 
     return null;
   }
 
 
   /**
    * @task lintunit
    */
   private function runUnit() {
     if ($this->getArgument('nounit') ||
         $this->getArgument('only') ||
-        $this->isRawDiffSource()) {
+        $this->isRawDiffSource() ||
+        $this->getArgument('head')) {
       return ArcanistUnitWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("Running unit tests...\n");
     try {
       $argv = $this->getPassthruArgumentsAsArgv('unit');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
       $unit_workflow = $this->buildChildWorkflow('unit', $argv);
       $unit_result = $unit_workflow->run();
 
       switch ($unit_result) {
         case ArcanistUnitWorkflow::RESULT_OKAY:
           $this->console->writeOut(
             "<bg:green>** UNIT OKAY **</bg> No unit test failures.\n");
           break;
         case ArcanistUnitWorkflow::RESULT_UNSOUND:
           if ($this->getArgument('ignore-unsound-tests')) {
             echo phutil_console_format(
               "<bg:yellow>** UNIT UNSOUND **</bg> Unit testing raised errors, ".
               "but all failing tests are unsound.\n");
           } else {
             $continue = $this->console->confirm(
               'Unit test results included failures, but all failing tests '.
               'are known to be unsound. Ignore unsound test failures?');
             if (!$continue) {
               throw new ArcanistUserAbortException();
             }
           }
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           $this->console->writeOut(
             "<bg:red>** UNIT ERRORS **</bg> Unit testing raised errors!\n");
           $this->getErrorExcuse(
             'unit',
             'Unit test results include failures!',
             'unit-excuses');
           break;
       }
 
       $this->testResults = array();
       foreach ($unit_workflow->getTestResults() as $test) {
         $this->testResults[] = array(
           'name'      => $test->getName(),
           'link'      => $test->getLink(),
           'result'    => $test->getResult(),
           'userdata'  => $test->getUserData(),
           'coverage'  => $test->getCoverage(),
           'extra'     => $test->getExtraData(),
         );
       }
 
       return $unit_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "No unit test engine is configured for this project.\n");
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut($ex->getMessage()."\n");
     }
 
     return null;
   }
 
   public function getTestResults() {
     return $this->testResults;
   }
 
   private function getSkipExcuse($prompt, $history) {
     $excuse = $this->getArgument('excuse');
 
     if ($excuse === null) {
       $history = $this->getRepositoryAPI()->getScratchFilePath($history);
       $excuse = phutil_console_prompt($prompt, $history);
       if ($excuse == '') {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $excuse;
   }
 
   private function getErrorExcuse($type, $prompt, $history) {
     if ($this->getArgument('excuse')) {
       $this->console->sendMessage(array(
         'type'    => $type,
         'confirm'  => $prompt.' Ignore them?',
       ));
       return;
     }
 
     $history = $this->getRepositoryAPI()->getScratchFilePath($history);
 
     $prompt .= ' Provide explanation to continue or press Enter to abort.';
     $this->console->writeOut("\n\n%s", phutil_console_wrap($prompt));
     $this->console->sendMessage(array(
       'type'    => $type,
       'prompt'  => 'Explanation:',
       'history' => $history,
     ));
   }
 
   public function handleServerMessage(PhutilConsoleMessage $message) {
     $data = $message->getData();
 
     if ($this->getArgument('excuse')) {
       try {
         phutil_console_require_tty();
       } catch (PhutilConsoleStdinNotInteractiveException $ex) {
         $this->excuses[$data['type']] = $this->getArgument('excuse');
         return null;
       }
     }
 
     $response = '';
     if (isset($data['prompt'])) {
       $response = phutil_console_prompt($data['prompt'], idx($data, 'history'));
     } else if (phutil_console_confirm($data['confirm'])) {
       $response = $this->getArgument('excuse');
     }
     if ($response == '') {
       throw new ArcanistUserAbortException();
     }
     $this->excuses[$data['type']] = $response;
     return null;
   }
 
 
 /* -(  Commit and Update Messages  )----------------------------------------- */
 
 
   /**
    * @task message
    */
   private function buildCommitMessage() {
     if ($this->getArgument('preview') || $this->getArgument('only')) {
       return null;
     }
 
     $is_create = $this->getArgument('create');
     $is_update = $this->getArgument('update');
     $is_raw = $this->isRawDiffSource();
     $is_message = $this->getArgument('use-commit-message');
     $is_verbatim = $this->getArgument('verbatim');
 
     if ($is_message) {
       return $this->getCommitMessageFromCommit($is_message);
     }
 
     if ($is_verbatim) {
       return $this->getCommitMessageFromUser();
     }
 
 
     if (!$is_raw && !$is_create && !$is_update) {
       $repository_api = $this->getRepositoryAPI();
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array(
           'authors' => array($this->getUserPHID()),
           'status'  => 'status-open',
         ));
       if (!$revisions) {
         $is_create = true;
       } else if (count($revisions) == 1) {
         $revision = head($revisions);
         $is_update = $revision['id'];
       } else {
         throw new ArcanistUsageException(
           "There are several revisions which match the working copy:\n\n".
           $this->renderRevisionList($revisions)."\n".
           "Use '--update' to choose one, or '--create' to create a new ".
           "revision.");
       }
     }
 
     $message = null;
     if ($is_create) {
       $message_file = $this->getArgument('message-file');
       if ($message_file) {
         return $this->getCommitMessageFromFile($message_file);
       } else {
         return $this->getCommitMessageFromUser();
       }
     } else if ($is_update) {
       $revision_id = $this->normalizeRevisionID($is_update);
       if (!is_numeric($revision_id)) {
         throw new ArcanistUsageException(
           'Parameter to --update must be a Differential Revision number');
       }
       return $this->getCommitMessageFromRevision($revision_id);
     } else {
       // This is --raw without enough info to create a revision, so force just
       // a diff.
       return null;
     }
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromCommit($commit) {
     $text = $this->getRepositoryAPI()->getCommitMessage($commit);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
     $message->pullDataFromConduit($this->getConduit());
     $this->validateCommitMessage($message);
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromUser() {
     $conduit = $this->getConduit();
 
     $template = null;
 
     if (!$this->getArgument('verbatim')) {
       $saved = $this->readScratchFile('create-message');
       if ($saved) {
         $where = $this->getReadableScratchFilePath('create-message');
 
         $preview = explode("\n", $saved);
         $preview = array_shift($preview);
         $preview = trim($preview);
         $preview = phutil_utf8_shorten($preview, 64);
 
         if ($preview) {
           $preview = "Message begins:\n\n       {$preview}\n\n";
         } else {
           $preview = null;
         }
 
         echo
           "You have a saved revision message in '{$where}'.\n".
           "{$preview}".
           "You can use this message, or discard it.";
 
         $use = phutil_console_confirm(
           'Do you want to use this message?',
           $default_no = false);
         if ($use) {
           $template = $saved;
         } else {
           $this->removeScratchFile('create-message');
         }
       }
     }
 
     $template_is_default = false;
     $notes = array();
     $included = array();
 
     list($fields, $notes, $included_commits) = $this->getDefaultCreateFields();
     if ($template) {
       $fields = array();
       $notes = array();
     } else {
       if (!$fields) {
         $template_is_default = true;
       }
 
       if ($notes) {
         $commit = head($this->getRepositoryAPI()->getLocalCommitInformation());
         $template = $commit['message'];
       } else {
         $template = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => null,
             'edit'        => 'create',
             'fields'      => $fields,
           ));
       }
     }
 
     $old_message = $template;
 
     $included = array();
     if ($included_commits) {
       foreach ($included_commits as $commit) {
         $included[] = '        '.$commit;
       }
       $in_branch = '';
       if (!$this->isRawDiffSource()) {
         $in_branch = ' in branch '.$this->getRepositoryAPI()->getBranchName();
       }
       $included = array_merge(
         array(
           '',
           "Included commits{$in_branch}:",
           '',
         ),
         $included);
     }
 
     $issues = array_merge(
       array(
         'NEW DIFFERENTIAL REVISION',
         'Describe the changes in this new revision.',
       ),
       $included,
       array(
         '',
         'arc could not identify any existing revision in your working copy.',
         'If you intended to update an existing revision, use:',
         '',
         '  $ arc diff --update <revision>',
       ));
     if ($notes) {
       $issues = array_merge($issues, array(''), $notes);
     }
 
     $done = false;
     $first = true;
     while (!$done) {
       $template = rtrim($template, "\r\n")."\n\n";
       foreach ($issues as $issue) {
         $template .= '# '.$issue."\n";
       }
       $template .= "\n";
 
       if ($first && $this->getArgument('verbatim') && !$template_is_default) {
         $new_template = $template;
       } else {
         $new_template = $this->newInteractiveEditor($template)
           ->setName('new-commit')
           ->editInteractively();
       }
       $first = false;
 
       if ($template_is_default && ($new_template == $template)) {
         throw new ArcanistUsageException('Template not edited.');
       }
 
       $template = ArcanistCommentRemover::removeComments($new_template);
 
       // With --raw-command, we may not have a repository API.
       if ($this->hasRepositoryAPI()) {
         $repository_api = $this->getRepositoryAPI();
         // special check for whether to amend here. optimizes a common git
         // workflow. we can't do this for mercurial because the mq extension
         // is popular and incompatible with hg commit --amend ; see T2011.
         $should_amend = (count($included_commits) == 1 &&
                          $repository_api instanceof ArcanistGitAPI &&
                          $this->shouldAmend());
       } else {
         $should_amend = false;
       }
 
       if ($should_amend) {
         $wrote = (rtrim($old_message) != rtrim($template));
         if ($wrote) {
           $repository_api->amendCommit($template);
           $where = 'commit message';
         }
       } else {
         $wrote = $this->writeScratchFile('create-message', $template);
         $where = "'".$this->getReadableScratchFilePath('create-message')."'";
       }
 
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $template);
         $message->pullDataFromConduit($conduit);
         $this->validateCommitMessage($message);
         $done = true;
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         echo "Commit message has errors:\n\n";
         $issues = array('Resolve these errors:');
         foreach ($ex->getParserErrors() as $error) {
           echo phutil_console_wrap("- ".$error."\n", 6);
           $issues[] = '  - '.$error;
         }
         echo "\n";
         echo 'You must resolve these errors to continue.';
         $again = phutil_console_confirm(
           'Do you want to edit the message?',
           $default_no = false);
         if ($again) {
           // Keep going.
         } else {
           $saved = null;
           if ($wrote) {
             $saved = "A copy was saved to {$where}.";
           }
           throw new ArcanistUsageException(
             "Message has unresolved errrors. {$saved}");
         }
       } catch (Exception $ex) {
         if ($wrote) {
           echo phutil_console_wrap("(Message saved to {$where}.)\n");
         }
         throw $ex;
       }
     }
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromFile($file) {
     $conduit = $this->getConduit();
 
     $data = Filesystem::readFile($file);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($data);
     $message->pullDataFromConduit($conduit);
 
     $this->validateCommitMessage($message);
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromRevision($revision_id) {
     $id = $revision_id;
 
     $revision = $this->getConduit()->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($id),
       ));
     $revision = head($revision);
 
     if (!$revision) {
       throw new ArcanistUsageException(
         "Revision '{$revision_id}' does not exist!");
     }
 
     $this->checkRevisionOwnership($revision);
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $id,
         'edit'        => false,
       ));
     $this->commitMessageFromRevision = $message;
 
     $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
     $obj->pullDataFromConduit($this->getConduit());
 
     return $obj;
   }
 
 
   /**
    * @task message
    */
   private function validateCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
     $futures = array();
 
     $revision_id = $message->getRevisionID();
     if ($revision_id) {
       $futures['revision'] = $this->getConduit()->callMethod(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
     }
 
     $reviewers = $message->getFieldValue('reviewerPHIDs');
     if (!$reviewers) {
       $confirm = 'You have not specified any reviewers. Continue anyway?';
       if (!phutil_console_confirm($confirm)) {
         throw new ArcanistUsageException('Specify reviewers and retry.');
       }
     } else {
       $futures['reviewers'] = $this->getConduit()->callMethod(
         'user.query',
         array(
           'phids' => $reviewers,
         ));
     }
 
     foreach (Futures($futures) as $key => $future) {
       $result = $future->resolve();
       switch ($key) {
         case 'revision':
           if (empty($result)) {
             throw new ArcanistUsageException(
               "There is no revision D{$revision_id}.");
           }
           $this->checkRevisionOwnership(head($result));
           break;
         case 'reviewers':
           $untils = array();
           foreach ($result as $user) {
             if (idx($user, 'currentStatus') == 'away') {
               $untils[] = $user['currentStatusUntil'];
             }
           }
           if (count($untils) == count($reviewers)) {
             $until = date('l, M j Y', min($untils));
             $confirm = "All reviewers are away until {$until}. ".
                        "Continue anyway?";
             if (!phutil_console_confirm($confirm)) {
               throw new ArcanistUsageException(
                 'Specify available reviewers and retry.');
             }
           }
           break;
       }
     }
 
   }
 
 
   /**
    * @task message
    */
   private function getUpdateMessage(array $fields, $template = '') {
     if ($this->getArgument('raw')) {
       throw new ArcanistUsageException(
         "When using '--raw' to update a revision, specify an update message ".
         "with '--message'. (Normally, we'd launch an editor to ask you for a ".
         "message, but can not do that because stdin is the diff source.)");
     }
 
     // When updating a revision using git without specifying '--message', try
     // to prefill with the message in HEAD if it isn't a template message. The
     // idea is that if you do:
     //
     //  $ git commit -a -m 'fix some junk'
     //  $ arc diff
     //
     // ...you shouldn't have to retype the update message. Similar things apply
     // to Mercurial.
 
     if ($template == '') {
       $comments = $this->getDefaultUpdateMessage();
 
       $template =
         rtrim($comments).
         "\n\n".
         "# Updating D{$fields['revisionID']}: {$fields['title']}\n".
         "#\n".
         "# Enter a brief description of the changes included in this update.\n".
         "# The first line is used as subject, next lines as comment.\n".
         "#\n".
         "# If you intended to create a new revision, use:\n".
         "#  $ arc diff --create\n".
         "\n";
     }
 
     $comments = $this->newInteractiveEditor($template)
       ->setName('differential-update-comments')
       ->editInteractively();
 
     return $comments;
   }
 
   private function getDefaultCreateFields() {
     $result = array(array(), array(), array());
 
     if ($this->isRawDiffSource()) {
       return $result;
     }
 
     $repository_api = $this->getRepositoryAPI();
     $local = $repository_api->getLocalCommitInformation();
     if ($local) {
       $result = $this->parseCommitMessagesIntoFields($local);
       if ($this->getArgument('create')) {
         unset($result[0]['revisionID']);
       }
     }
 
     $result[0] = $this->dispatchWillBuildEvent($result[0]);
 
     return $result;
   }
 
   /**
    * Convert a list of commits from `getLocalCommitInformation()` into
    * a format usable by arc to create a new diff. Specifically, we emit:
    *
    *   - A dictionary of commit message fields.
    *   - A list of errors encountered while parsing the messages.
    *   - A human-readable list of the commits themselves.
    *
    * For example, if the user runs "arc diff HEAD^^^" and selects a diff range
    * which includes several diffs, we attempt to merge them somewhat
    * intelligently into a single message, because we can only send one
    * "Summary:", "Reviewers:", etc., field to Differential. We also return
    * errors (e.g., if the user typed a reviewer name incorrectly) and a
    * summary of the commits themselves.
    *
    * @param dict  Local commit information.
    * @return list Complex output, see summary.
    * @task message
    */
   private function parseCommitMessagesIntoFields(array $local) {
     $conduit = $this->getConduit();
     $local = ipull($local, null, 'commit');
 
     // If the user provided "--reviewers" or "--ccs", add a faux message to
     // the list with the implied fields.
 
     $faux_message = array();
     if ($this->getArgument('reviewers')) {
       $faux_message[] = 'Reviewers: '.$this->getArgument('reviewers');
     }
     if ($this->getArgument('cc')) {
       $faux_message[] = 'CC: '.$this->getArgument('cc');
     }
 
     if ($faux_message) {
       $faux_message = implode("\n\n", $faux_message);
       $local = array(
         '(Flags)     ' => array(
           'message' => $faux_message,
           'summary' => 'Command-Line Flags',
         ),
       ) + $local;
     }
 
     // Build a human-readable list of the commits, so we can show the user which
     // commits are included in the diff.
     $included = array();
     foreach ($local as $hash => $info) {
       $included[] = substr($hash, 0, 12).' '.$info['summary'];
     }
 
     // Parse all of the messages into fields.
     $messages = array();
     foreach ($local as $hash => $info) {
       $text = $info['message'];
       if (trim($text) == self::AUTO_COMMIT_TITLE) {
         continue;
       }
       $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       $messages[$hash] = $obj;
     }
 
     $notes = array();
     $fields = array();
     foreach ($messages as $hash => $message) {
       try {
         $message->pullDataFromConduit($conduit, $partial = true);
         $fields[$hash] = $message->getFields();
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         if ($this->getArgument('verbatim')) {
           // In verbatim mode, just bail when we hit an error. The user can
           // rerun without --verbatim if they want to fix it manually. Most
           // users will probably `git commit --amend` instead.
           throw $ex;
         }
         $fields[$hash] = $message->getFields();
 
         $frev = substr($hash, 0, 12);
         $notes[] = "NOTE: commit {$frev} could not be completely parsed:";
         foreach ($ex->getParserErrors() as $error) {
           $notes[] = "  - {$error}";
         }
       }
     }
 
     // Merge commit message fields. We do this somewhat-intelligently so that
     // multiple "Reviewers" or "CC" fields will merge into the concatenation
     // of all values.
 
     // We have special parsing rules for 'title' because we can't merge
     // multiple titles, and one-line commit messages like "fix stuff" will
     // parse as titles. Instead, pick the first title we encounter. When we
     // encounter subsequent titles, treat them as part of the summary. Then
     // we merge all the summaries together below.
 
     $result = array();
 
     // Process fields in oldest-first order, so earlier commits get to set the
     // title of record and reviewers/ccs are listed in chronological order.
     $fields = array_reverse($fields);
 
     foreach ($fields as $hash => $dict) {
       $title = idx($dict, 'title');
       if (!strlen($title)) {
         continue;
       }
 
       if (!isset($result['title'])) {
         // We don't have a title yet, so use this one.
         $result['title'] = $title;
       } else {
         // We already have a title, so merge this new title into the summary.
         $summary = idx($dict, 'summary');
         if ($summary) {
           $summary = $title."\n\n".$summary;
         } else {
           $summary = $title;
         }
         $fields[$hash]['summary'] = $summary;
       }
     }
 
     // Now, merge all the other fields in a general sort of way.
 
     foreach ($fields as $hash => $dict) {
       foreach ($dict as $key => $value) {
         if ($key == 'title') {
           // This has been handled above, and either assigned directly or
           // merged into the summary.
           continue;
         }
 
         if (is_array($value)) {
           // For array values, merge the arrays, appending the new values.
           // Examples are "Reviewers" and "Cc", where this produces a list of
           // all users specified as reviewers.
           $cur = idx($result, $key, array());
           $new = array_merge($cur, $value);
           $result[$key] = $new;
           continue;
         } else {
           if (!strlen(trim($value))) {
             // Ignore empty fields.
             continue;
           }
 
           // For string values, append the new field to the old field with
           // a blank line separating them. Examples are "Test Plan" and
           // "Summary".
           $cur = idx($result, $key, '');
           if (strlen($cur)) {
             $new = $cur."\n\n".$value;
           } else {
             $new = $value;
           }
           $result[$key] = $new;
         }
       }
     }
 
     return array($result, $notes, $included);
   }
 
   private function getDefaultUpdateMessage() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistGitAPI) {
       return $this->getGitUpdateMessage();
     }
 
     if ($repository_api instanceof ArcanistMercurialAPI) {
       return $this->getMercurialUpdateMessage();
     }
 
     return null;
   }
 
   /**
    * Retrieve the git messages between HEAD and the last update.
    *
    * @task message
    */
   private function getGitUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $commit_messages = $repository_api->getGitCommitLog();
     $commit_messages = $parser->parseDiff($commit_messages);
 
     if (count($commit_messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     // We have more than one message, so figure out which ones are new. We
     // do this by pulling the current diff and comparing commit hashes in the
     // working copy with attached commit hashes. It's not super important that
     // we always get this 100% right, we're just trying to do something
     // reasonable.
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($commit_messages as $message) {
       $text = $message->getMetadata('message');
 
       $parsed = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       if ($parsed->getRevisionID()) {
         // If this is an amended commit message with a revision ID, it's
         // certainly not new. Stop marking commits as usable and break out.
         break;
       }
 
       if (isset($hashes[$message->getCommitHash()])) {
         // If this commit is currently part of the diff, stop using commit
         // messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $text;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
   /**
    * Retrieve the hg messages between tip and the last update.
    *
    * @task message
    */
   private function getMercurialUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $messages = $repository_api->getCommitMessageLog();
 
     if (count($messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($messages as $rev => $message) {
       if (isset($hashes[$rev])) {
         // If this commit is currently part of the active diff on the revision,
         // stop using commit messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $message;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
 
   /**
    * Format log messages to prefill a diff update.
    *
    * @task message
    */
   private function formatUsableLogs(array $usable) {
     // Flip messages so they'll read chronologically (oldest-first) in the
     // template, e.g.:
     //
     //   - Added foobar.
     //   - Fixed foobar bug.
     //   - Documented foobar.
 
     $usable = array_reverse($usable);
     $default = array();
     foreach ($usable as $message) {
       // Pick the first line out of each message.
       $text = trim($message);
       if ($text == self::AUTO_COMMIT_TITLE) {
         continue;
       }
       $text = head(explode("\n", $text));
       $default[] = '  - '.$text."\n";
     }
 
     return implode('', $default);
   }
 
   private function loadActiveLocalCommitInfo() {
     $current_diff = $this->getConduit()->callMethodSynchronous(
       'differential.getdiff',
       array(
         'revision_id' => $this->revisionID,
       ));
 
     $properties = idx($current_diff, 'properties', array());
     return idx($properties, 'local:commits', array());
   }
 
 
 /* -(  Diff Specification  )------------------------------------------------- */
 
 
   /**
    * @task diffspec
    */
   private function getLintStatus($lint_result) {
     $map = array(
       ArcanistLintWorkflow::RESULT_OKAY       => 'okay',
       ArcanistLintWorkflow::RESULT_ERRORS     => 'fail',
       ArcanistLintWorkflow::RESULT_WARNINGS   => 'warn',
       ArcanistLintWorkflow::RESULT_SKIP       => 'skip',
       ArcanistLintWorkflow::RESULT_POSTPONED  => 'postponed',
     );
     return idx($map, $lint_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function getUnitStatus($unit_result) {
     $map = array(
       ArcanistUnitWorkflow::RESULT_OKAY       => 'okay',
       ArcanistUnitWorkflow::RESULT_FAIL       => 'fail',
       ArcanistUnitWorkflow::RESULT_UNSOUND    => 'warn',
       ArcanistUnitWorkflow::RESULT_SKIP       => 'skip',
       ArcanistUnitWorkflow::RESULT_POSTPONED  => 'postponed',
     );
     return idx($map, $unit_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function buildDiffSpecification() {
 
     $base_revision  = null;
     $base_path      = null;
     $vcs            = null;
     $repo_uuid      = null;
     $parent         = null;
     $source_path    = null;
     $branch         = null;
     $bookmark       = null;
 
     if (!$this->isRawDiffSource()) {
       $repository_api = $this->getRepositoryAPI();
 
       $base_revision  = $repository_api->getSourceControlBaseRevision();
       $base_path      = $repository_api->getSourceControlPath();
       $vcs            = $repository_api->getSourceControlSystemName();
       $source_path    = $repository_api->getPath();
       $branch         = $repository_api->getBranchName();
       $repo_uuid      = $repository_api->getRepositoryUUID();
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $info = $this->getGitParentLogInfo();
         if ($info['parent']) {
           $parent = $info['parent'];
         }
         if ($info['base_revision']) {
           $base_revision = $info['base_revision'];
         }
         if ($info['base_path']) {
           $base_path = $info['base_path'];
         }
         if ($info['uuid']) {
           $repo_uuid = $info['uuid'];
         }
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
 
         $bookmark = $repository_api->getActiveBookmark();
         $svn_info = $repository_api->getSubversionInfo();
         $repo_uuid = idx($svn_info, 'uuid');
         $base_path = idx($svn_info, 'base_path', $base_path);
         $base_revision = idx($svn_info, 'base_revision', $base_revision);
 
         // TODO: provide parent info
 
       }
     }
 
     $project_id = null;
     if ($this->requiresWorkingCopy()) {
       $project_id = $this->getWorkingCopy()->getProjectID();
     }
 
     $data = array(
       'sourceMachine'             => php_uname('n'),
       'sourcePath'                => $source_path,
       'branch'                    => $branch,
       'bookmark'                  => $bookmark,
       'sourceControlSystem'       => $vcs,
       'sourceControlPath'         => $base_path,
       'sourceControlBaseRevision' => $base_revision,
       'creationMethod'            => 'arc',
       'arcanistProject'           => $project_id,
     );
 
     if (!$this->isRawDiffSource()) {
       $repository_phid = $this->getRepositoryPHID();
       if ($repository_phid) {
         $data['repositoryPHID'] = $repository_phid;
       }
     }
 
     return $data;
   }
 
 
 /* -(  Diff Properties  )---------------------------------------------------- */
 
 
   /**
    * Update lint information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateLintDiffProperty() {
     if (strlen($this->excuses['lint'])) {
       $this->updateDiffProperty('arc:lint-excuse',
         json_encode($this->excuses['lint']));
     }
 
     if ($this->unresolvedLint) {
       $this->updateDiffProperty('arc:lint', json_encode($this->unresolvedLint));
     }
 
     $postponed = $this->postponedLinters;
     if ($postponed) {
       $this->updateDiffProperty('arc:lint-postponed', json_encode($postponed));
     }
 
   }
 
 
   /**
    * Update unit test information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateUnitDiffProperty() {
     if (strlen($this->excuses['unit'])) {
       $this->updateDiffProperty('arc:unit-excuse',
         json_encode($this->excuses['unit']));
     }
 
     if ($this->testResults) {
       $this->updateDiffProperty('arc:unit', json_encode($this->testResults));
     }
   }
 
 
   /**
    * Update local commit information for the diff.
    *
    * @task diffprop
    */
   private function updateLocalDiffProperty() {
     if ($this->isRawDiffSource()) {
       return;
     }
 
     $local_info = $this->getRepositoryAPI()->getLocalCommitInformation();
     if (!$local_info) {
       return;
     }
 
     $this->updateDiffProperty('local:commits', json_encode($local_info));
   }
 
 
   /**
    * Update an arbitrary diff property.
    *
    * @param string Diff property name.
    * @param string Diff property value.
    * @return void
    *
    * @task diffprop
    */
   private function updateDiffProperty($name, $data) {
     $this->diffPropertyFutures[] = $this->getConduit()->callMethod(
       'differential.setdiffproperty',
       array(
         'diff_id' => $this->getDiffID(),
         'name'    => $name,
         'data'    => $data,
       ));
   }
 
   /**
    * Wait for finishing all diff property updates.
    *
    * @return void
    *
    * @task diffprop
    */
   private function resolveDiffPropertyUpdates() {
     Futures($this->diffPropertyFutures)->resolveAll();
     $this->diffPropertyFutures = array();
   }
 
   private function dispatchWillCreateRevisionEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_REVISION_WILLCREATEREVISION,
       array(
         'specification' => $fields,
       ));
 
     return $event->getValue('specification');
   }
 
   private function dispatchWillBuildEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WILLBUILDMESSAGE,
       array(
         'fields' => $fields,
       ));
 
     return $event->getValue('fields');
   }
 
   private function checkRevisionOwnership(array $revision) {
     if ($revision['authorPHID'] == $this->getUserPHID()) {
       return;
     }
 
     $id = $revision['id'];
     $title = $revision['title'];
 
     throw new ArcanistUsageException(
       "You don't own revision D{$id} '{$title}'. You can only update ".
       "revisions you own. You can 'Commandeer' this revision from the web ".
       "interface if you want to become the owner.");
   }
 
 
 /* -(  File Uploads  )------------------------------------------------------- */
 
 
   private function uploadFilesForChanges(array $changes) {
     assert_instances_of($changes, 'ArcanistDiffChange');
 
     // Collect all the files we need to upload.
 
     $need_upload = array();
     foreach ($changes as $key => $change) {
       if ($change->getFileType() != ArcanistDiffChangeType::FILE_BINARY) {
         continue;
       }
 
       if ($this->getArgument('skip-binaries')) {
         continue;
       }
 
       $name = basename($change->getCurrentPath());
 
       $need_upload[] = array(
         'type' => 'old',
         'name' => $name,
         'data' => $change->getOriginalFileData(),
         'change' => $change,
       );
 
       $need_upload[] = array(
         'type' => 'new',
         'name' => $name,
         'data' => $change->getCurrentFileData(),
         'change' => $change,
       );
     }
 
     if (!$need_upload) {
       return;
     }
 
     // Determine mime types and file sizes. Update changes from "binary" to
     // "image" if the file is an image. Set image metadata.
 
     $type_image = ArcanistDiffChangeType::FILE_IMAGE;
     foreach ($need_upload as $key => $spec) {
       $change = $need_upload[$key]['change'];
 
       $type = $spec['type'];
       $size = strlen($spec['data']);
 
       $change->setMetadata("{$type}:file:size", $size);
       if ($spec['data'] === null) {
         // This covers the case where a file was added or removed; we don't
         // need to upload the other half of it (e.g., the old file data for
         // a file which was just added). This is distinct from an empty
         // file, which we do upload.
         unset($need_upload[$key]);
         continue;
       }
 
       $mime = $this->getFileMimeType($spec['data']);
       if (preg_match('@^image/@', $mime)) {
         $change->setFileType($type_image);
       }
 
       $change->setMetadata("{$type}:file:mime-type", $mime);
     }
 
     echo pht('Uploading %d files...', count($need_upload))."\n";
 
     // Now we're ready to upload the actual file data. If possible, we'll just
     // transmit a hash of the file instead of the actual file data. If the data
     // already exists, Phabricator can share storage. Check if we can use
     // "file.uploadhash" yet (i.e., if the server is up to date enough).
     // TODO: Drop this check once we bump the protocol version.
     $conduit_methods = $this->getConduit()->callMethodSynchronous(
       'conduit.query',
       array());
     $can_use_hash_upload = isset($conduit_methods['file.uploadhash']);
 
     if ($can_use_hash_upload) {
       $hash_futures = array();
       foreach ($need_upload as $key => $spec) {
         $hash_futures[$key] = $this->getConduit()->callMethod(
           'file.uploadhash',
           array(
             'name' => $spec['name'],
             'hash' => sha1($spec['data']),
           ));
       }
 
       foreach (Futures($hash_futures)->limit(8) as $key => $future) {
         $type = $need_upload[$key]['type'];
         $change = $need_upload[$key]['change'];
         $name = $need_upload[$key]['name'];
 
         $phid = null;
         try {
           $phid = $future->resolve();
         } catch (Exception $e) {
           // Just try uploading normally if the hash upload failed.
           continue;
         }
 
         if ($phid) {
           $change->setMetadata("{$type}:binary-phid", $phid);
           unset($need_upload[$key]);
           echo pht("Uploaded '%s' (%s).", $name, $type)."\n";
         }
       }
     }
 
     $upload_futures = array();
     foreach ($need_upload as $key => $spec) {
       $upload_futures[$key] = $this->getConduit()->callMethod(
         'file.upload',
         array(
           'name' => $spec['name'],
           'data_base64' => base64_encode($spec['data']),
         ));
     }
 
     foreach (Futures($upload_futures)->limit(4) as $key => $future) {
       $type = $need_upload[$key]['type'];
       $change = $need_upload[$key]['change'];
       $name = $need_upload[$key]['name'];
 
       try {
         $phid = $future->resolve();
         $change->setMetadata("{$type}:binary-phid", $phid);
         echo pht("Uploaded '%s' (%s).", $name, $type)."\n";
       } catch (Exception $e) {
         echo "Failed to upload {$type} binary '{$name}'.\n\n";
         echo $e->getMessage()."\n";
         if (!phutil_console_confirm('Continue?', $default_no = false)) {
           throw new ArcanistUsageException(
             'Aborted due to file upload failure. You can use --skip-binaries '.
             'to skip binary uploads.');
         }
       }
     }
 
     echo pht('Upload complete.')."\n";
   }
 
   private function getFileMimeType($data) {
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     return Filesystem::getMimeType($tmp);
   }
 
 }
diff --git a/src/workflow/ArcanistExportWorkflow.php b/src/workflow/ArcanistExportWorkflow.php
index ae6d33f4..481f0c5b 100644
--- a/src/workflow/ArcanistExportWorkflow.php
+++ b/src/workflow/ArcanistExportWorkflow.php
@@ -1,274 +1,276 @@
 <?php
 
 /**
  * Exports changes from Differential or the working copy to a file.
  *
  * @group workflow
  */
 final class ArcanistExportWorkflow extends ArcanistBaseWorkflow {
 
   const SOURCE_LOCAL      = 'local';
   const SOURCE_DIFF       = 'diff';
   const SOURCE_REVISION   = 'revision';
 
   const FORMAT_GIT        = 'git';
   const FORMAT_UNIFIED    = 'unified';
   const FORMAT_BUNDLE     = 'arcbundle';
 
   private $source;
   private $sourceID;
   private $format;
 
   public function getWorkflowName() {
     return 'export';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **export** [__paths__] __format__ (svn)
       **export** [__commit_range__] __format__ (git, hg)
       **export** __--revision__ __revision_id__ __format__
       **export** __--diff__ __diff_id__ __format__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn, git, hg
           Export the local changeset (or a Differential changeset) to a file,
           in some __format__: git diff (__--git__), unified diff
           (__--unified__), or arc bundle (__--arcbundle__ __path__) format.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'git' => array(
         'help' =>
           "Export change as a git patch. This format is more complete than ".
           "unified, but less complete than arc bundles. These patches can be ".
           "applied with 'git apply' or 'arc patch'.",
       ),
       'unified' => array(
         'help' =>
           "Export change as a unified patch. This format is less complete ".
           "than git patches or arc bundles. These patches can be applied with ".
           "'patch' or 'arc patch'.",
       ),
       'arcbundle' => array(
         'param' => 'file',
         'help' =>
           "Export change as an arc bundle. This format can represent all ".
           "changes. These bundles can be applied with 'arc patch'.",
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           'Attempt to convert non UTF-8 patch into specified encoding.',
       ),
       'revision' => array(
         'param' => 'revision_id',
         'help' =>
           'Instead of exporting changes from the working copy, export them '.
           'from a Differential revision.'
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' =>
           'Instead of exporting changes from the working copy, export them '.
           'from a Differential diff.'
       ),
       '*' => 'paths',
     );
   }
 
 
   protected function didParseArguments() {
     $source = self::SOURCE_LOCAL;
     $requested = 0;
     if ($this->getArgument('revision')) {
       $source = self::SOURCE_REVISION;
       $requested++;
 
       $source_id = $this->getArgument($source);
       $this->sourceID = $this->normalizeRevisionID($source_id);
     }
     if ($this->getArgument('diff')) {
       $source = self::SOURCE_DIFF;
       $requested++;
 
       $this->sourceID = $this->getArgument($source);
     }
     $this->source = $source;
 
     if ($requested > 1) {
       throw new ArcanistUsageException(
       "Options '--revision' and '--diff' are not compatible. Choose exactly ".
       "one change source.");
     }
 
 
     $format = null;
     $requested = 0;
     if ($this->getArgument('git')) {
       $format = self::FORMAT_GIT;
       $requested++;
     }
     if ($this->getArgument('unified')) {
       $format = self::FORMAT_UNIFIED;
       $requested++;
     }
     if ($this->getArgument('arcbundle')) {
       $format = self::FORMAT_BUNDLE;
       $requested++;
     }
 
     if ($requested === 0) {
       throw new ArcanistUsageException(
         "Specify one of '--git', '--unified' or '--arcbundle <path>' to ".
         "choose an export format.");
     } else if ($requested > 1) {
       throw new ArcanistUsageException(
         "Options '--git', '--unified' and '--arcbundle' are not compatible. ".
         "Choose exactly one export format.");
     }
 
     $this->format = $format;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return $this->requiresConduit();
   }
 
   public function requiresRepositoryAPI() {
     return $this->getSource() == self::SOURCE_LOCAL;
   }
 
   public function requiresWorkingCopy() {
     return $this->getSource() == self::SOURCE_LOCAL;
   }
 
   private function getSource() {
     return $this->source;
   }
 
   private function getSourceID() {
     return $this->sourceID;
   }
 
   private function getFormat() {
     return $this->format;
   }
 
   public function run() {
 
     $source = $this->getSource();
 
     switch ($source) {
       case self::SOURCE_LOCAL:
         $repository_api = $this->getRepositoryAPI();
         $parser = new ArcanistDiffParser();
         $parser->setRepositoryAPI($repository_api);
 
         if ($repository_api instanceof ArcanistGitAPI) {
           $this->parseBaseCommitArgument($this->getArgument('paths'));
-          $diff = $repository_api->getFullGitDiff();
+          $diff = $repository_api->getFullGitDiff(
+            $repository_api->getBaseCommit(),
+            $repository_api->getHeadCommit());
           $changes = $parser->parseDiff($diff);
           $authors = $this->getConduit()->callMethodSynchronous(
             'user.query',
             array(
               'phids' => array($this->getUserPHID()),
             ));
           $author_dict = reset($authors);
 
           list($email) = $repository_api->execxLocal('config user.email');
 
           $author = sprintf('%s <%s>',
             $author_dict['realName'],
             $email);
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $this->parseBaseCommitArgument($this->getArgument('paths'));
           $diff = $repository_api->getFullMercurialDiff();
           $changes = $parser->parseDiff($diff);
           $authors = $this->getConduit()->callMethodSynchronous(
             'user.query',
             array(
               'phids' => array($this->getUserPHID()),
             ));
 
           list($author) = $repository_api->execxLocal('showconfig ui.username');
         } else {
           // TODO: paths support
           $paths = $repository_api->getWorkingCopyStatus();
           $changes = $parser->parseSubversionDiff(
             $repository_api,
             $paths);
           $author = $this->getUserName();
         }
 
         $bundle = ArcanistBundle::newFromChanges($changes);
         $bundle->setProjectID($this->getWorkingCopy()->getProjectID());
         $bundle->setBaseRevision(
           $repository_api->getSourceControlBaseRevision());
         // note we can't get a revision ID for SOURCE_LOCAL
 
         $parser = new PhutilEmailAddress($author);
         $bundle->setAuthorName($parser->getDisplayName());
         $bundle->setAuthorEmail($parser->getAddress());
         break;
       case self::SOURCE_REVISION:
         $bundle = $this->loadRevisionBundleFromConduit(
           $this->getConduit(),
           $this->getSourceID());
         break;
       case self::SOURCE_DIFF:
         $bundle = $this->loadDiffBundleFromConduit(
           $this->getConduit(),
           $this->getSourceID());
         break;
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
     if (!$try_encoding) {
       try {
         $project_info = $this->getConduit()->callMethodSynchronous(
           'arcanist.projectinfo',
           array(
             'name' => $bundle->getProjectID(),
           ));
         $try_encoding = $project_info['encoding'];
       } catch (ConduitClientException $e) {
         $try_encoding = null;
       }
     }
 
     if ($try_encoding) {
       $bundle->setEncoding($try_encoding);
     }
 
     $format = $this->getFormat();
 
     switch ($format) {
       case self::FORMAT_GIT:
         echo $bundle->toGitPatch();
         break;
       case self::FORMAT_UNIFIED:
         echo $bundle->toUnifiedDiff();
         break;
       case self::FORMAT_BUNDLE:
         $path = $this->getArgument('arcbundle');
         echo "Writing bundle to '{$path}'...\n";
         $bundle->writeToDisk($path);
         echo "done.\n";
         break;
     }
 
     return 0;
   }
 }
diff --git a/src/workflow/ArcanistWhichWorkflow.php b/src/workflow/ArcanistWhichWorkflow.php
index d8b2815d..1160d4e8 100644
--- a/src/workflow/ArcanistWhichWorkflow.php
+++ b/src/workflow/ArcanistWhichWorkflow.php
@@ -1,242 +1,259 @@
 <?php
 
 /**
  * Show which revision or revisions are in the working copy.
  *
  * @group workflow
  */
 final class ArcanistWhichWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'which';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **which** (svn)
       **which** [commit] (hg, git)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn, git, hg
           Shows which repository the current working copy corresponds to,
           which commits 'arc diff' will select, and which revision is in
           the working copy (or which revisions, if more than one matches).
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'any-status' => array(
         'help' => 'Show committed and abandoned revisions.',
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => 'Additional rules for determining base revision.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
       'show-base' => array(
         'help'  => 'Print base commit only and exit.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
+      'head' => array(
+        'param' => 'commit',
+        'help' => 'specify the head commit.'
+      ),
       '*' => 'commit',
     );
   }
 
   public function run() {
 
     $console = PhutilConsole::getConsole();
 
     $this->printRepositorySection();
     $console->writeOut("\n");
 
     $repository_api = $this->getRepositoryAPI();
 
     $arg_commit = $this->getArgument('commit');
     if (count($arg_commit)) {
       $this->parseBaseCommitArgument($arg_commit);
     }
     $arg = $arg_commit ? ' '.head($arg_commit) : '';
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
-    if ($repository_api->supportsCommitRanges()) {
+    $supports_ranges = $repository_api->supportsCommitRanges();
+
+    if ($this->getArgument('head')) {
+      if ($supports_ranges === false) {
+        throw new Exception('--head is not supported in this VCS');
+      }
+
+      $head_commit = $this->getArgument('head');
+      $arg .= " --head {$head_commit}";
+      $repository_api->setHeadCommit($head_commit);
+    }
+
+    if ($supports_ranges) {
       $relative = $repository_api->getBaseCommit();
 
       if ($this->getArgument('show-base')) {
         echo $relative."\n";
         return 0;
       }
 
       $info = $repository_api->getLocalCommitInformation();
       if ($info) {
         $commits = array();
         foreach ($info as $commit) {
           $hash     = substr($commit['commit'], 0, 16);
           $summary  = $commit['summary'];
 
           $commits[] = "    {$hash}  {$summary}";
         }
         $commits = implode("\n", $commits);
       } else {
         $commits = '    (No commits.)';
       }
 
       $explanation = $repository_api->getBaseCommitExplanation();
 
       $relative_summary = $repository_api->getCommitSummary($relative);
       $relative = substr($relative, 0, 16);
 
       if ($repository_api instanceof ArcanistGitAPI) {
-        $command = "git diff {$relative}..HEAD";
+        $head = $this->getArgument('head', 'HEAD');
+        $command = "git diff {$relative}..{$head}";
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
         $command = "hg diff --rev {$relative}";
       } else {
         throw new Exception('Unknown VCS!');
       }
 
       echo phutil_console_wrap(
         phutil_console_format(
           "**RELATIVE COMMIT**\n".
           "If you run 'arc diff{$arg}', changes between the commit:\n\n"));
 
       echo  "    {$relative}  {$relative_summary}\n\n";
       echo phutil_console_wrap(
         "...and the current working copy state will be sent to ".
         "Differential, because {$explanation}\n\n".
         "You can see the exact changes that will be sent by running ".
         "this command:\n\n".
         "    $ {$command}\n\n".
         "These commits will be included in the diff:\n\n");
 
       echo $commits."\n\n\n";
     }
 
     $any_status = $this->getArgument('any-status');
 
     $query = array(
       'status' => $any_status
         ? 'status-any'
         : 'status-open',
     );
 
     $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       $query);
 
     echo phutil_console_wrap(
       phutil_console_format(
         "**MATCHING REVISIONS**\n".
         "These Differential revisions match the changes in this working ".
         "copy:\n\n"));
 
     if (empty($revisions)) {
       echo "    (No revisions match.)\n";
       echo "\n";
       echo phutil_console_wrap(
         phutil_console_format(
           "Since there are no revisions in Differential which match this ".
           "working copy, a new revision will be **created** if you run ".
           "'arc diff{$arg}'.\n\n"));
     } else {
       $other_author_phids = array();
       foreach ($revisions as $revision) {
         if ($revision['authorPHID'] != $this->getUserPHID()) {
           $other_author_phids[] = $revision['authorPHID'];
         }
       }
 
       $other_authors = array();
       if ($other_author_phids) {
         $other_authors = $this->getConduit()->callMethodSynchronous(
           'user.query',
           array(
             'phids' => $other_author_phids,
           ));
         $other_authors = ipull($other_authors, 'userName', 'phid');
       }
 
       foreach ($revisions as $revision) {
         $title = $revision['title'];
         $monogram = 'D'.$revision['id'];
 
         if ($revision['authorPHID'] != $this->getUserPHID()) {
           $author = $other_authors[$revision['authorPHID']];
           echo pht("    %s (%s) %s\n", $monogram, $author, $title);
         } else {
           echo pht("    %s %s\n", $monogram, $title);
         }
 
         echo '        Reason: '.$revision['why']."\n";
         echo "\n";
       }
       if (count($revisions) == 1) {
         echo phutil_console_wrap(
           phutil_console_format(
             "Since exactly one revision in Differential matches this working ".
             "copy, it will be **updated** if you run 'arc diff{$arg}'."));
       } else {
         echo phutil_console_wrap(
           "Since more than one revision in Differential matches this working ".
           "copy, you will be asked which revision you want to update if ".
           "you run 'arc diff {$arg}'.");
       }
       echo "\n\n";
     }
 
     return 0;
   }
 
   private function printRepositorySection() {
     $console = PhutilConsole::getConsole();
     $console->writeOut("**%s**\n", pht('REPOSITORY'));
 
     $callsign = $this->getRepositoryCallsign();
 
     $console->writeOut(
       "%s\n\n",
       pht(
         'To identify the repository associated with this working copy, '.
         'arc followed this process:'));
 
     foreach ($this->getRepositoryReasons() as $reason) {
       $reason = phutil_console_wrap($reason, 4);
       $console->writeOut("%s\n\n", $reason);
     }
 
     if ($callsign) {
       $console->writeOut(
         "%s\n",
         pht('This working copy is associated with the %s repository.',
         phutil_console_format('**%s**', $callsign)));
     } else {
       $console->writeOut(
         "%s\n",
         pht('This working copy is not associated with any repository.'));
     }
   }
 
 }