diff --git a/Documentation/glossary.txt b/Documentation/glossary.txt
index 02a9d9c18a..39c90ad7a6 100644
--- a/Documentation/glossary.txt
+++ b/Documentation/glossary.txt
@@ -1,39 +1,71 @@
-object::
-	The unit of storage in git. It is uniquely identified by
-	the SHA1 of its contents. Consequently, an object can not
-	be changed.
+alternate object database::
+	Via the alternates mechanism, a repository can inherit part of its
+	object database from another object database, which is called
+	"alternate".
 
-object name::
-	The unique identifier of an object. The hash of the object's contents
-	using the Secure Hash Algorithm 1 and usually represented by the 40
-	character hexadecimal encoding of the hash of the object (possibly
-	followed by a white space).
-
-SHA1::
-	Synonym for object name.
-
-object identifier::
-	Synonym for object name.
-
-hash::
-	In git's context, synonym to object name.
-
-object database::
-	Stores a set of "objects", and an individual object is identified
-	by its object name. The objects usually live in `$GIT_DIR/objects/`.
+bare repository::
+	A bare repository is normally an appropriately named
+	directory with a `.git` suffix that does not have a
+	locally checked-out copy of any of the files under revision
+	control.  That is, all of the `git` administrative and
+	control files that would normally be present in the
+	hidden `.git` sub-directory are directly present in
+	the `repository.git` directory instead, and no other files
+	are present and checked out.  Usually publishers of public
+	repositories make bare repositories available.
 
 blob object::
 	Untyped object, e.g. the contents of a file.
 
-tree object::
-	An object containing a list of file names and modes along with refs
-	to the associated blob and/or tree objects. A tree is equivalent
-	to a directory.
+branch::
+	A non-cyclical graph of revisions, i.e. the complete history of
+	a particular revision, which is called the branch head. The
+	branch heads are stored in `$GIT_DIR/refs/heads/`.
 
-tree::
-	Either a working tree, or a tree object together with the
-	dependent blob and tree objects (i.e. a stored representation
-	of a working tree).
+cache::
+	Obsolete for: index.
+
+chain::
+	A list of objects, where each object in the list contains a
+	reference to its successor (for example, the successor of a commit
+	could be one of its parents).
+
+changeset::
+	BitKeeper/cvsps speak for "commit". Since git does not store
+	changes, but states, it really does not make sense to use
+	the term "changesets" with git.
+
+checkout::
+	The action of updating the working tree to a revision which was
+	stored in the object database.
+
+cherry-picking::
+	In SCM jargon, "cherry pick" means to choose a subset of
+	changes out of a series of changes (typically commits)
+	and record them as a new series of changes on top of
+	different codebase.  In GIT, this is performed by
+	"git cherry-pick" command to extract the change
+	introduced by an existing commit and to record it based
+	on the tip of the current branch as a new commit.
+
+clean::
+	A working tree is clean, if it corresponds to the revision
+	referenced by the current head.  Also see "dirty".
+
+commit::
+	As a verb: The action of storing the current state of the index in the
+	object database. The result is a revision.
+	As a noun: Short hand for commit object.
+
+commit object::
+	An object which contains the information about a particular
+	revision, such as parents, committer, author, date and the
+	tree object which corresponds to the top directory of the
+	stored revision.
+
+core git::
+	Fundamental data structures and utilities of git. Exposes only
+	limited source code management tools.
 
 DAG::
 	Directed acyclic graph. The commit objects form a directed acyclic
@@ -41,6 +73,63 @@ DAG::
 	objects is acyclic (there is no chain which begins and ends with the
 	same object).
 
+dircache::
+	You are *waaaaay* behind.
+
+dirty::
+	A working tree is said to be dirty if it contains modifications
+	which have not been committed to the current branch.
+
+directory::
+	The list you get with "ls" :-)
+
+ent::
+	Favorite synonym to "tree-ish" by some total geeks. See
+	`http://en.wikipedia.org/wiki/Ent_(Middle-earth)` for an in-depth
+	explanation.
+
+fast forward::
+	A fast-forward is a special type of merge where you have
+	a revision and you are "merging" another branch's changes
+	that happen to be a descendant of what you have.
+	In such these cases, you do not make a new merge commit but
+	instead just update to his revision. This will happen
+	frequently on a tracking branch of a remote repository.
+
+fetch::
+	Fetching a branch means to get the branch's head ref from a
+	remote repository, to find out which objects are missing from
+	the local object database, and to get them, too.
+
+file system::
+	Linus Torvalds originally designed git to be a user space file
+	system, i.e. the infrastructure to hold files and directories.
+	That ensured the efficiency and speed of git.
+
+git archive::
+	Synonym for repository (for arch people).
+
+hash::
+	In git's context, synonym to object name.
+
+head::
+	The top of a branch. It contains a ref to the corresponding
+	commit object.
+
+head ref::
+	A ref pointing to a head. Often, this is abbreviated to "head".
+	Head refs are stored in `$GIT_DIR/refs/heads/`.
+
+hook::
+	During the normal execution of several git commands,
+	call-outs are made to optional scripts that allow
+	a developer to add functionality or checking.
+	Typically, the hooks allow for a command to be pre-verified
+	and potentially aborted, and allow for a post-notification
+	after the operation is done.
+	The hook scripts are found in the `$GIT_DIR/hooks/` directory,
+	and are enabled by simply making them executable.
+
 index::
 	A collection of files with stat information, whose contents are
 	stored as objects. The index is a stored version of your working
@@ -53,92 +142,167 @@ index entry::
 	yet finished (i.e. if the index contains multiple versions of
 	that file).
 
-unmerged index:
-	An index which contains unmerged index entries.
+master::
+	The default development branch. Whenever you create a git
+	repository, a branch named "master" is created, and becomes
+	the active branch. In most cases, this contains the local
+	development, though that is purely conventional and not required.
 
-cache::
-	Obsolete for: index.
+merge::
+	To merge branches means to try to accumulate the changes since a
+	common ancestor and apply them to the first branch. An automatic
+	merge uses heuristics to accomplish that. Evidently, an automatic
+	merge can fail.
 
-working tree::
-	The set of files and directories currently being worked on,
-	i.e. you can work in your working tree without using git at all.
+object::
+	The unit of storage in git. It is uniquely identified by
+	the SHA1 of its contents. Consequently, an object can not
+	be changed.
 
-directory::
-	The list you get with "ls" :-)
+object database::
+	Stores a set of "objects", and an individual object is identified
+	by its object name. The objects usually live in `$GIT_DIR/objects/`.
 
-revision::
-	A particular state of files and directories which was stored in
-	the object database. It is referenced by a commit object.
+object identifier::
+	Synonym for object name.
 
-checkout::
-	The action of updating the working tree to a revision which was
-	stored in the object database.
+object name::
+	The unique identifier of an object. The hash of the object's contents
+	using the Secure Hash Algorithm 1 and usually represented by the 40
+	character hexadecimal encoding of the hash of the object (possibly
+	followed by a white space).
 
-commit::
-	As a verb: The action of storing the current state of the index in the
-	object database. The result is a revision.
-	As a noun: Short hand for commit object.
+object type:
+	One of the identifiers "commit","tree","tag" and "blob" describing
+	the type of an object.
 
-commit object::
-	An object which contains the information about a particular
-	revision, such as parents, committer, author, date and the
-	tree object which corresponds to the top directory of the
-	stored revision.
+octopus::
+	To merge more than two branches. Also denotes an intelligent
+	predator.
+
+origin::
+	The default upstream tracking branch. Most projects have at
+	least one upstream project which they track. By default
+	'origin' is used for that purpose.  New upstream updates
+	will be fetched into this branch; you should never commit
+	to it yourself.
+
+pack::
+	A set of objects which have been compressed into one file (to save
+	space or to transmit them efficiently).
+
+pack index::
+	The list of identifiers, and other information, of the objects in a
+	pack, to assist in efficiently accessing the contents of a pack.
 
 parent::
 	A commit object contains a (possibly empty) list of the logical
 	predecessor(s) in the line of development, i.e. its parents.
 
-changeset::
-	BitKeeper/cvsps speak for "commit". Since git does not store
-	changes, but states, it really does not make sense to use
-	the term "changesets" with git.
+pickaxe::
+	The term pickaxe refers to an option to the diffcore routines
+	that help select changes that add or delete a given text string.
+	With the --pickaxe-all option, it can be used to view the
+	full changeset that introduced or removed, say, a particular
+	line of text.  See gitlink:git-diff[1].
 
-clean::
-	A working tree is clean, if it corresponds to the revision
-	referenced by the current head.
+plumbing::
+	Cute name for core git.
 
-dirty::
-	A working tree is said to be dirty if it contains modifications
-	which have not been committed to the current branch.
+porcelain::
+	Cute name for programs and program suites depending on core git,
+	presenting a high level access to core git. Porcelains expose
+	more of a SCM interface than the plumbing.
 
-head::
-	The top of a branch. It contains a ref to the corresponding
-	commit object.
+pull::
+	Pulling a branch means to fetch it and merge it.
 
-branch::
-	A non-cyclical graph of revisions, i.e. the complete history of
-	a particular revision, which is called the branch head. The
-	branch heads are stored in `$GIT_DIR/refs/heads/`.
+push::
+	Pushing a branch means to get the branch's head ref from a remote
+	repository, find out if it is an ancestor to the branch's local
+	head ref is a direct, and in that case, putting all objects, which
+	are reachable from the local head ref, and which are missing from
+	the remote repository, into the remote object database, and updating
+	the remote head ref. If the remote head is not an ancestor to the
+	local head, the push fails.
 
-master::
-	The default branch. Whenever you create a git repository, a branch
-	named "master" is created, and becomes the active branch. In most
-	cases, this contains the local development.
+reachable::
+	An object is reachable from a ref/commit/tree/tag, if there is a
+	chain leading from the latter to the former.
 
-origin::
-	The default upstream branch. Most projects have one upstream
-	project which they track, and by default 'origin' is used for
-	that purpose.  New updates from upstream will be fetched into
-	this branch; you should never commit to it yourself.
+rebase::
+	To clean a branch by starting from the head of the main line of
+	development ("master"), and reapply the (possibly cherry-picked)
+	changes from that branch.
 
 ref::
-	A 40-byte hex representation of a SHA1 pointing to a particular
-	object. These may be stored in `$GIT_DIR/refs/`.
+	A 40-byte hex representation of a SHA1 or a name that denotes
+	a particular object. These may be stored in `$GIT_DIR/refs/`.
 
-head ref::
-	A ref pointing to a head. Often, this is abbreviated to "head".
-	Head refs are stored in `$GIT_DIR/refs/heads/`.
+refspec::
+	A refspec is used by fetch and push to describe the mapping
+	between remote ref and local ref.  They are combined with
+	a colon in the format <src>:<dst>, preceded by an optional
+	plus sign, +.  For example:
+	`git fetch $URL refs/heads/master:refs/heads/origin`
+	means "grab the master branch head from the $URL and store
+	it as my origin branch head".
+	And `git push $URL refs/heads/master:refs/heads/to-upstream`
+	means "publish my master branch head as to-upstream master head
+	at $URL".   See also gitlink:git-push[1]
+
+repository::
+	A collection of refs together with an object database containing
+	all objects, which are reachable from the refs, possibly accompanied
+	by meta data from one or more porcelains. A repository can
+	share an object database with other repositories.
+
+resolve::
+	The action of fixing up manually what a failed automatic merge
+	left behind.
+
+revision::
+	A particular state of files and directories which was stored in
+	the object database. It is referenced by a commit object.
+
+rewind::
+	To throw away part of the development, i.e. to assign the head to
+	an earlier revision.
+
+SCM::
+	Source code management (tool).
+
+SHA1::
+	Synonym for object name.
+
+topic branch::
+	A regular git branch that is used by a developer to
+	identify a conceptual line of development.  Since branches
+	are very easy and inexpensive, it is often desirable to
+	have several small branches that each contain very well
+	defined concepts or small incremental yet related changes.
+
+tracking branch::
+	A regular git branch that is used to follow changes from
+	another repository.  A tracking branch should not contain
+	direct modifications or have local commits made to it.
+	A tracking branch can usually be identified as the
+	right-hand-side ref in a Pull: refspec.
+
+tree object::
+	An object containing a list of file names and modes along with refs
+	to the associated blob and/or tree objects. A tree is equivalent
+	to a directory.
+
+tree::
+	Either a working tree, or a tree object together with the
+	dependent blob and tree objects (i.e. a stored representation
+	of a working tree).
 
 tree-ish::
 	A ref pointing to either a commit object, a tree object, or a
 	tag object pointing to a tag or commit or tree object.
 
-ent::
-	Favorite synonym to "tree-ish" by some total geeks. See
-	`http://en.wikipedia.org/wiki/Ent_(Middle-earth)` for an in-depth
-	explanation.
-
 tag object::
 	An object containing a ref pointing to another object, which can
 	contain a message just like a commit object. It can also
@@ -153,101 +317,10 @@ tag::
 	A tag is most typically used to mark a particular point in the
 	commit ancestry chain.
 
-merge::
-	To merge branches means to try to accumulate the changes since a
-	common ancestor and apply them to the first branch. An automatic
-	merge uses heuristics to accomplish that. Evidently, an automatic
-	merge can fail.
+unmerged index:
+	An index which contains unmerged index entries.
 
-octopus::
-	To merge more than two branches. Also denotes an intelligent
-	predator.
-
-resolve::
-	The action of fixing up manually what a failed automatic merge
-	left behind.
-
-rewind::
-	To throw away part of the development, i.e. to assign the head to
-	an earlier revision.
-
-rebase::
-	To clean a branch by starting from the head of the main line of
-	development ("master"), and reapply the (possibly cherry-picked)
-	changes from that branch.
-
-repository::
-	A collection of refs together with an object database containing
-	all objects, which are reachable from the refs, possibly accompanied
-	by meta data from one or more porcelains. A repository can
-	share an object database with other repositories.
-
-git archive::
-	Synonym for repository (for arch people).
-
-file system::
-	Linus Torvalds originally designed git to be a user space file
-	system, i.e. the infrastructure to hold files and directories.
-	That ensured the efficiency and speed of git.
-
-alternate object database::
-	Via the alternates mechanism, a repository can inherit part of its
-	object database from another object database, which is called
-	"alternate".
-
-reachable::
-	An object is reachable from a ref/commit/tree/tag, if there is a
-	chain leading from the latter to the former.
-
-chain::
-	A list of objects, where each object in the list contains a
-	reference to its successor (for example, the successor of a commit
-	could be one of its parents).
-
-fetch::
-	Fetching a branch means to get the branch's head ref from a
-	remote repository, to find out which objects are missing from
-	the local object database, and to get them, too.
-
-pull::
-	Pulling a branch means to fetch it and merge it.
-
-push::
-	Pushing a branch means to get the branch's head ref from a remote
-	repository, find out if it is an ancestor to the branch's local
-	head ref is a direct, and in that case, putting all objects, which
-	are reachable from the local head ref, and which are missing from
-	the remote repository, into the remote object database, and updating
-	the remote head ref. If the remote head is not an ancestor to the
-	local head, the push fails.
-
-pack::
-	A set of objects which have been compressed into one file (to save
-	space or to transmit them efficiently).
-
-pack index::
-	The list of identifiers, and other information, of the objects in a
-	pack, to assist in efficiently accessing the contents of a pack. 
-
-core git::
-	Fundamental data structures and utilities of git. Exposes only
-	limited source code management tools.
-
-plumbing::
-	Cute name for core git.
-
-porcelain::
-	Cute name for programs and program suites depending on core git,
-	presenting a high level access to core git. Porcelains expose
-	more of a SCM interface than the plumbing.
-
-object type:
-	One of the identifiers "commit","tree","tag" and "blob" describing
-	the type of an object.
-
-SCM::
-	Source code management (tool).
-
-dircache::
-	You are *waaaaay* behind.
+working tree::
+	The set of files and directories currently being worked on,
+	i.e. you can work in your working tree without using git at all.
 
diff --git a/Documentation/sort_glossary.pl b/Documentation/sort_glossary.pl
index e57dc78e0e..e0bc552a64 100644
--- a/Documentation/sort_glossary.pl
+++ b/Documentation/sort_glossary.pl
@@ -48,7 +48,7 @@ ($)
 ';
 
 @keys=sort {uc($a) cmp uc($b)} keys %terms;
-$pattern='(\b'.join('\b|\b',reverse @keys).'\b)';
+$pattern='(\b(?<!link:git-)'.join('\b|\b(?<!link:git-)',reverse @keys).'\b)';
 foreach $key (@keys) {
 	$terms{$key}=~s/$pattern/sprintf "<<ref_".no_spaces($1).",$1>>";/eg;
 	print '[[ref_'.no_spaces($key).']]'.$key."::\n"
diff --git a/Makefile b/Makefile
index ecbdde6ef9..e9d9e101d3 100644
--- a/Makefile
+++ b/Makefile
@@ -215,8 +215,8 @@ LIB_OBJS = \
 	$(DIFF_OBJS)
 
 BUILTIN_OBJS = \
-	builtin-log.o builtin-help.o builtin-count.o builtin-diff.o \
-	builtin-push.o builtin-grep.o
+	builtin-log.o builtin-help.o builtin-count.o builtin-diff.o builtin-push.o \
+	builtin-grep.o
 
 GITLIBS = $(LIB_FILE) $(XDIFF_LIB)
 LIBS = $(GITLIBS) -lz
diff --git a/builtin-diff.c b/builtin-diff.c
index b6114ce948..636edbf2a7 100644
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -271,7 +271,7 @@ int cmd_diff(int argc, const char **argv, char **envp)
 	 *
 	 * Other cases are errors.
 	 */
-	
+
 	git_config(git_diff_config);
 	init_revisions(&rev);
 	rev.diffopt.output_format = DIFF_FORMAT_PATCH;
@@ -321,7 +321,7 @@ int cmd_diff(int argc, const char **argv, char **envp)
 			blob[blobs].name = name;
 			blobs++;
 			continue;
-			
+
 		}
 		die("unhandled object '%s' given.", name);
 	}
diff --git a/builtin.h b/builtin.h
index 7f06812b86..97e2464468 100644
--- a/builtin.h
+++ b/builtin.h
@@ -19,9 +19,10 @@ extern int cmd_version(int argc, const char **argv, char **envp);
 extern int cmd_whatchanged(int argc, const char **argv, char **envp);
 extern int cmd_show(int argc, const char **argv, char **envp);
 extern int cmd_log(int argc, const char **argv, char **envp);
+extern int cmd_diff(int argc, const char **argv, char **envp);
 extern int cmd_format_patch(int argc, const char **argv, char **envp);
 extern int cmd_count_objects(int argc, const char **argv, char **envp);
-extern int cmd_diff(int argc, const char **argv, char **envp);
+
 extern int cmd_push(int argc, const char **argv, char **envp);
 extern int cmd_grep(int argc, const char **argv, char **envp);
 
diff --git a/contrib/remotes2config.sh b/contrib/remotes2config.sh
new file mode 100644
index 0000000000..25901e2b3b
--- /dev/null
+++ b/contrib/remotes2config.sh
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# Use this tool to rewrite your .git/remotes/ files into the config.
+
+. git-sh-setup
+
+if [ -d "$GIT_DIR"/remotes ]; then
+	echo "Rewriting $GIT_DIR/remotes" >&2
+	error=0
+	# rewrite into config
+	{
+		cd "$GIT_DIR"/remotes
+		ls | while read f; do
+			name=$(echo -n "$f" | tr -c "A-Za-z0-9" ".")
+			sed -n \
+			-e "s/^URL: \(.*\)$/remote.$name.url \1 ./p" \
+			-e "s/^Pull: \(.*\)$/remote.$name.fetch \1 ^$ /p" \
+			-e "s/^Push: \(.*\)$/remote.$name.push \1 ^$ /p" \
+			< "$f"
+		done
+		echo done
+	} | while read key value regex; do
+		case $key in
+		done)
+			if [ $error = 0 ]; then
+				mv "$GIT_DIR"/remotes "$GIT_DIR"/remotes.old
+			fi ;;
+		*)
+			echo "git-repo-config $key "$value" $regex"
+			git-repo-config $key "$value" $regex || error=1 ;;
+		esac
+	done
+fi
+
+
diff --git a/diff.c b/diff.c
index 6762fcee5a..c845c87113 100644
--- a/diff.c
+++ b/diff.c
@@ -1018,14 +1018,12 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
 	}
 
 	if (memcmp(one->sha1, two->sha1, 20)) {
-		char one_sha1[41];
 		int abbrev = o->full_index ? 40 : DEFAULT_ABBREV;
-		memcpy(one_sha1, sha1_to_hex(one->sha1), 41);
 
 		len += snprintf(msg + len, sizeof(msg) - len,
 				"index %.*s..%.*s",
-				abbrev, one_sha1, abbrev,
-				sha1_to_hex(two->sha1));
+				abbrev, sha1_to_hex(one->sha1),
+				abbrev, sha1_to_hex(two->sha1));
 		if (one->mode == two->mode)
 			len += snprintf(msg + len, sizeof(msg) - len,
 					" %06o", one->mode);
diff --git a/git-parse-remote.sh b/git-parse-remote.sh
index c9b899e3d7..187f0883c9 100755
--- a/git-parse-remote.sh
+++ b/git-parse-remote.sh
@@ -10,7 +10,10 @@ get_data_source () {
 		# Not so fast.	This could be the partial URL shorthand...
 		token=$(expr "z$1" : 'z\([^/]*\)/')
 		remainder=$(expr "z$1" : 'z[^/]*/\(.*\)')
-		if test -f "$GIT_DIR/branches/$token"
+		if test "$(git-repo-config --get "remote.$token.url")"
+		then
+			echo config-partial
+		elif test -f "$GIT_DIR/branches/$token"
 		then
 			echo branches-partial
 		else
@@ -18,7 +21,10 @@ get_data_source () {
 		fi
 		;;
 	*)
-		if test -f "$GIT_DIR/remotes/$1"
+		if test "$(git-repo-config --get "remote.$1.url")"
+		then
+			echo config
+		elif test -f "$GIT_DIR/remotes/$1"
 		then
 			echo remotes
 		elif test -f "$GIT_DIR/branches/$1"
@@ -35,6 +41,15 @@ get_remote_url () {
 	case "$data_source" in
 	'')
 		echo "$1" ;;
+	config-partial)
+		token=$(expr "z$1" : 'z\([^/]*\)/')
+		remainder=$(expr "z$1" : 'z[^/]*/\(.*\)')
+		url=$(git-repo-config --get "remote.$token.url")
+		echo "$url/$remainder"
+		;;
+	config)
+		git-repo-config --get "remote.$1.url"
+		;;
 	remotes)
 		sed -ne '/^URL: */{
 			s///p
@@ -56,8 +71,10 @@ get_remote_url () {
 get_remote_default_refs_for_push () {
 	data_source=$(get_data_source "$1")
 	case "$data_source" in
-	'' | branches | branches-partial)
+	'' | config-partial | branches | branches-partial)
 		;; # no default push mapping, just send matching refs.
+	config)
+		git-repo-config --get-all "remote.$1.push" ;;
 	remotes)
 		sed -ne '/^Push: */{
 			s///p
@@ -111,8 +128,11 @@ canon_refs_list_for_fetch () {
 get_remote_default_refs_for_fetch () {
 	data_source=$(get_data_source "$1")
 	case "$data_source" in
-	'' | branches-partial)
+	'' | config-partial | branches-partial)
 		echo "HEAD:" ;;
+	config)
+		canon_refs_list_for_fetch \
+			$(git-repo-config --get-all "remote.$1.fetch") ;;
 	branches)
 		remote_branch=$(sed -ne '/#/s/.*#//p' "$GIT_DIR/branches/$1")
 		case "$remote_branch" in '') remote_branch=master ;; esac
diff --git a/git.c b/git.c
index d5f0faa907..84803a62e6 100644
--- a/git.c
+++ b/git.c
@@ -46,10 +46,10 @@ static void handle_internal_command(int argc, const char **argv, char **envp)
 		{ "log", cmd_log },
 		{ "whatchanged", cmd_whatchanged },
 		{ "show", cmd_show },
+		{ "push", cmd_push },
 		{ "fmt-patch", cmd_format_patch },
 		{ "count-objects", cmd_count_objects },
 		{ "diff", cmd_diff },
-		{ "push", cmd_push },
 		{ "grep", cmd_grep },
 	};
 	int i;
diff --git a/merge-tree.c b/merge-tree.c
index 50528d5e43..cc7b5bd891 100644
--- a/merge-tree.c
+++ b/merge-tree.c
@@ -24,16 +24,14 @@ static const char *sha1_to_hex_zero(const unsigned char *sha1)
 
 static void resolve(const char *base, struct name_entry *branch1, struct name_entry *result)
 {
-	char branch1_sha1[50];
-
 	/* If it's already branch1, don't bother showing it */
 	if (!branch1)
 		return;
-	memcpy(branch1_sha1, sha1_to_hex_zero(branch1->sha1), 41);
 
 	printf("0 %06o->%06o %s->%s %s%s\n",
 		branch1->mode, result->mode,
-		branch1_sha1, sha1_to_hex_zero(result->sha1),
+		sha1_to_hex_zero(branch1->sha1),
+		sha1_to_hex_zero(result->sha1),
 		base, result->path);
 }
 
diff --git a/sha1_file.c b/sha1_file.c
index f2d33afb27..5464828259 100644
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -108,9 +108,10 @@ int safe_create_leading_directories(char *path)
 
 char * sha1_to_hex(const unsigned char *sha1)
 {
-	static char buffer[50];
+	static int bufno;
+	static char hexbuffer[4][50];
 	static const char hex[] = "0123456789abcdef";
-	char *buf = buffer;
+	char *buffer = hexbuffer[3 & ++bufno], *buf = buffer;
 	int i;
 
 	for (i = 0; i < 20; i++) {