gitconfig

[alias]
	; Alternative: Do this programmatically:
	; 	git config --global alias.foo 'commit -m "foobar"'

	; Note: You cannot override a built-in Git command via an alias. Cp.
	; http://stackoverflow.com/questions/3538774/is-it-possible-to-override-git-command-by-git-alias
	;
	;alias = config --get-regexp 'alias\\..*' ; List all defined aliases.
	;; alias: List all Git aliases [starting with <pattern>].
	;; aliases: List all (documented) Git aliases, command extensions, and newly defined commands [starting with <pattern>].
	; Note: If you name the shell command "git-aliasname", there's no need
	; to define an alias here; Git will automatically pick it up; in fact,
	; git-aliasname takes precedence over the alias!
	;
	;alias = !git-alias
	; The following two definitions are equivalent (the second is preferred):
	;	echoalias1 = !git-echo fixed-argument
	;	echoalias2 = echo fixed-argument
	;
	; Note: You also cannot use a shell command "git-builtin" to override
	; the "git builtin" command! To achieve that, you need a custom "git"
	; shell function that intercepts the git call.
	; To do something with individual arguments, use something like this:
	;x = "!sh -c 'echo args: \"$@\"' -"
	; But I prefer defining an external git-subcommand for this.

	; Handle the common typo "git git COMMAND" through my wrapper. Note: Does not handle "git git-COMMAND".
	git = wrapper

	;; confighelp: Browse the user's gitconfig (for hints and suggestions).
	configlist = config --local --list
	configedit = config --local --edit

	me = config --get user.name
	me-in-github = config --get github.user

	; Stop recording the executable file mode.
	; This can be necessary when using both MSysGit and Cygwin's Git, and
	; "git diff" shows this output for every file:
	;   old mode 100755
	;   new mode 100644
	; Best set this locally only via
	;   git config core.filemode false
	;filemode = false
	config-no-filemode = config core.filemode false

	;; iscontrolled: Test whether the current directory / passed DIRSPEC is inside a Git working copy / the passed FILESPEC is tracked by Git (i.e. not unversioned).
	;; isnonemptyrepo: Test whether the current directory / passed DIRSPEC is a repository that has at least one commit in it. Fails if not a working copy or a just-initialized empty repo without any commits.

	;; init: Create an empty Git repository and automatically chdir into it.
	;; clone: Clone a repository into a new directory and automatically chdir into it.
	;; uclone: Clone a repository and name the remote repository "upstream" (commonly used for repos you don't own yourself) instead of the default "origin".

	;; system-setup: Setup system-specific Git configuration for a system.
	;; isworktree: Test whether the current working copy is a secondary worktree.
	;; isdetached: Test whether the current working copy directly refers to a particular commit as opposed to a named branch.

	;; cat: Retrieve the contents of <path> as it exists in revision <ref>.
	;; cp: Retrieve the contents of <path> as it exists in revision <ref> and save it as <path>.<ref> (or <target> if given).

	chp = cherry-pick --no-commit	; Apply the changes introduced by some existing commits (cummulatively) to the index and working copy.
	cherrypick = cherry-pick --no-commit	; Apply the changes introduced by some existing commits (cummulatively) to the index and working copy.
	chpc = cherry-pick --continue	; Commit (after adding resolved conflicts) and continue with any subsequent commits to be cherry-picked.
	chps = cherry-pick --quit	; Forget about the current (conflicted) operation in progress.
	chpq = cherry-pick --abort	; Cancel the operation and return to the pre-sequence state.
	cherrycommit = cherry-pick ; Apply and immediately commit each change (individually) introduced by some existing commit(s).
	;; cherrymerge: Apply and immediately commit each change (individually), recording the existing commit id(s) in the commit message, like the merge tracking in Subversion.

	;; unapply-index: Revert the changes in the index to the working copy.
	;; checkout-committed: Revert changes [for FILE(s)] in the working copy to the latest commit, but keep any changes in the index. These can be put back into the working copy via checkout.
	coc = checkout-committed
	;; checkoutprevious: Revert changes [for FILE(s)] in the working copy to the commit prior to passed <commit> / HEAD. Like "git checkout <commit>^ [-- FILE ...]" but doesn't write to the index / cause the "detached HEAD" status when no FILEs are passed. This is meant to be for temporary investigation or verifying a test failure without the committed fix, so no dirty working copy is allowed.
	cop = checkoutprevious
	;; checkoutpreviousselected: Interactively select (from files touched in <commit> / HEAD) files (or directly pass N, M, ... selections) to be reverted to what the content *before* <commit> was.
	cops = checkoutpreviousselected

	;;revert: Apply the reverted changes only to the index and working copy; the index does not have to match the HEAD commit, so you can revert multiple commits in a row.
	revertcommit = revert	; Apply the reverted changes and commit.
	revertselected = selectedcommit-command revert	; Apply the reverted changes interactively chosen from the commits in the passed <range> only to the index and working copy commit.
	revertcommitselected = selectedcommit-command revertcommit	; Apply the reverted changes interactively chosen from the commits in the passed <range> and commit.
	;; add: Add and show status; --all/-A stages all, . stages new and modified, without deleted, -u stages modified and deleted, without new.
	;; addn: Add all modified and deleted files except those matching FILE(s) or the escaped GLOB(s). Like addu, but with inverted meaning of the file arguments.
	;; addu: Stage modified and deleted, without new files, and show status.
	addhunk = add --patch	; Interactively cherry-pick and add individual hunks changed in the working copy to the index.
	addh = addhunk
	addedit = add --edit	; Interactively choose lines to stage by directly editing the diff.
	;; adddeleted: Add manually deleted (or moved) files to the index.
	;; addi: Add unstaged changes from already staged files; update stage.
	;; addr: Add from root (i.e. all in working copy, not just everything inside CWD); defaults to modified and deleted, without new.
	;; adduntracked: Add only new files, respecting the ignore patterns.
	addun = adduntracked
	;; adduu: Stage modified and deleted, and add new files, respecting the ignore patterns. Combination of git addu && git adduntracked.
	;; addselected: Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to stage by number.
	adds = addselected
	addselectedhunk = addselected --patch
	addsh = addselectedhunk
	addselectededit = addselected --edit
	addse = addselectededit
	;; addselecteduntracked: Interactively select (from new files, respecting the ignore patterns, or passed list of files) files (or directly pass N, M, ... selections) to stage by number.
	addsun = addselecteduntracked
	;; commituntracked: Commit only new files, respecting the ignore patterns.
	cun = commituntracked
	commitselected = selected-command commit	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to commit by number.
	cs = commitselected

	c = wrapper commit
	ca = commita
	;; commita: Commit all new files.
	cu = wrapper commit --all	; Commit all modified and deleted files, without new.
	commitu = wrapper commit --all	; Commit all modified and deleted files, without new.
	;; cuu: Commit modified and deleted, and add new files, respecting the ignore patterns. Combination of git adduu && git commit.
	;; correct: Commit as a correction of <commit> (when it's too late or cumbersome to fixup the existing commit). This just adds a reference to the prior commit in the commit message (title and body).
	;; fixup: Commit with the intent of squashing this with the passed <commit> (id or :/<pattern>) via interactive rebase later.
	correctselected = selectedcommit-command --single-only correct	; Commit as a correction of the commit interactively chosen from the commits in the passed <range> (when it's too late or cumbersome to fixup the existing commit).
	correctselected7 = correctselected --max-count 7
	correctst = stfiles-command selectedcommit-command --single-only correct	; Commit as a correction of the commit interactively chosen from the commits of currently modified files in the passed <range> (when it's too late or cumbersome to fixup the existing commit).
	correctst7 = correctst --max-count 7
	correcti = stifiles-command selectedcommit-command --single-only correct	; Commit as a correction of the commit interactively chosen from the commits of currently staged files in the passed <range> (when it's too late or cumbersome to fixup the existing commit).
	correcti7 = correcti --max-count 7
	correct-i = stIfiles-command selectedcommit-command --single-only correct	; Commit as a correction of the commit interactively chosen from the commits of currently modified but not staged files in the passed <range> (when it's too late or cumbersome to fixup the existing commit).
	correct-i7 = correct-i --max-count 7
	fixupselected = selectedcommit-command --single-only fixup	; Commit with the intent of squashing this with the commit interactively chosen from the commits in the passed <range> via interactive rebase later.
	fixupselected7 = fixupselected --max-count 7
	fixupst = stfiles-command selectedcommit-command --single-only fixup	; Commit with the intent of squashing this with the commit interactively chosen from the commits of currently modified files in the passed <range> via interactive rebase later.
	fixupst7 = fixupst --max-count 7
	fixupi = stifiles-command selectedcommit-command --single-only fixup	; Commit with the intent of squashing this with the commit interactively chosen from the commits of currently staged files in the passed <range> via interactive rebase later.
	fixupi7 = fixupi --max-count 7
	fixup-i = stIfiles-command selectedcommit-command --single-only fixup	; Commit with the intent of squashing this with the commit interactively chosen from the commits of currently modified but not staged files in the passed <range> via interactive rebase later.
	fixup-i7 = fixup-i --max-count 7
	;; rbfixup: Commit and squash with the passed <commit> (id or :/<pattern>) via interactive rebase.
	rbfixupselected = selectedcommit-command --single-only rbfixup	; Commit and squash with the commit interactively chosen from the commits in the passed <range> via interactive rebase.
	rbfixupselected7 = rbfixupselected --max-count 7
	amen = commit --amend --reuse-message=HEAD	; Amend to last commit without re-editing the message.
	amenu = commit --all --amend --reuse-message=HEAD	; Amend all modified and deleted files to last commit without re-editing the message.
	amend = commit --amend --reedit-message=HEAD	; Amend to last commit.
	amendu = commit --all --amend --reedit-message=HEAD	; Amend all modified and deleted files to last commit.
	amendonly = commit --amend --only	; Amend to last commit, ignoring any already staged changes.
	amenasme = mine-command amen	; Amend to last commit without re-editing the message and set the author to myself.
	amendasme = mine-command amend	; Amend to last commit and set the author to myself.
	;; commitfor: Commit for another author whose "NAME <EMAIL@HOST>" combo is either passed or selected from all previous committers (via passed AUTHOR-PATTERN).
	;; commitwithfiledate: Commit with the author date set to the most recent file modification date of files in the stage. Useful if you only now noticed that changes should have been committed a long time ago.
	;; commitidentical: Commit directly (without further edits) with the same commit message as <commit>.
	commitidenticalst = stfiles-command selectedcommit-command --single-only commitidentical	; Commit directly (without further edits) with the same commit message as the commit interactively chosen from the commits of currently modified files in the passed <range>.
	commitidenticalst7 = commitidenticalst --max-count 7
	commitidenticali = stifiles-command selectedcommit-command --single-only commitidentical	; Commit directly (without further edits) with the same commit message as the commit interactively chosen from the commits of currently staged files in the passed <range>.
	commitidenticali7 = commitidenticali --max-count 7
	commitidentical-i = stIfiles-command selectedcommit-command --single-only commitidentical	; Commit directly (without further edits) with the same commit message as the commit interactively chosen from the commits of currently modified but not staged files in the passed <range>.
	commitidentical-i7 = commitidentical-i --max-count 7
	commitidenticalselected = selectedcommit-command --single-only commitidentical	; Commit directly (without further edits) with the same commit message as the commit interactively chosen from the commits in the passed <range>.
	commitidenticalselected7 = commitidenticalselected --max-count 7
	cis = commitidenticalselected7
	commitlike = commitidentical --edit 	; Commit with the same commit message as <commit> as the base for further editing.
	commitlikest = stfiles-command selectedcommit-command --single-only commitlike	; Commit with the same commit message as the commit interactively chosen from the commits of currently modified files in the passed <range> as the base for further editing.
	commitlikest7 = commitlikest --max-count 7
	commitlikei = stifiles-command selectedcommit-command --single-only commitlike 	; Commit with the same commit message as the commit interactively chosen from the commits of currently staged files in the passed <range> as the base for further editing.
	commitlikei7 = commitlikei --max-count 7
	commitlike-i = stIfiles-command selectedcommit-command --single-only commitlike ; Commit with the same commit message as the commit interactively chosen from the commits of currently modified but not staged files in the passed <range> as the base for further editing.
	commitlike-i7 = commitlike-i --max-count 7
	commitlikeselected = selectedcommit-command --single-only commitlike	; Commit with the same commit message as the commit interactively chosen from the commits in the passed <range> as the base for further editing.
	commitlikeselected7 = commitlikeselected --max-count 7
	cls = commitlikeselected7
	;; credit: Amend another author whose "NAME <EMAIL@HOST>" combo is either passed or selected from all previous committers (via passed AUTHOR-PATTERN).
	;; show-branch: Shows the branch anchestry (heads are prefixed with !, current with *), then after a --- separator commits (+) and merges (-).
	;; br: branch with DWIM detection of branch listing via pattern (from the help: git branch <pattern> would try to create a branch, use git branch --list <pattern> to list matching branches).
	;; brname: Print current (local) branch name.
	;; bra: List (local; -r remote-tracking; -a both) branches (optionally filtered by <glob>) ordered by date of most recent commit.
	;; brc: List (local; -r remote-tracking; -a both) branches (optionally filtered by <glob>) ordered by date of first commit.
	;; createlocalbr: Create (and track) local branches for all remote branches (matching PATTERN).
	;; localbrdo: Check out all / the last committed N local branches (except for the current branch and master (and base branch if defined)) one by one and execute COMMAND (or drop back to the shell) for each).
	;; localbrcdo: Check out all / the last N local branches (except for the current branch and master (and base branch if defined)) ordered by date of first commit and execute COMMAND (or drop back to the shell) for each).
	;; localbrrefdo: Iterate over all / the last committed N local branches (except for the current branch and master (and base branch if defined)) one by one and execute COMMAND for each branch, replacing {} with its name.
	;; localbrcrefdo: Iterate over all / the last committed N local branches (except for the current branch and master (and base branch if defined)) ordered by date of first commit one by one and execute COMMAND for each branch, replacing {} with its name.
	;; prune: Remove old local branches that do not exist in <remote> any more.
	;; existsbr: Check whether [all of] the passed [<remote>/]<branch> exists.
	;; remotebr: Print corresponding remote/branch for the current branch (or return error).
	deletebr = branch -d	; Delete branch; use oldeletebr to remove the branch in origin, too (and odeletebr to just delete it in origin).
	deletelb = branch -d @{-1}	; Delete the last checked-out branch.
	renamebr = branch -m	; Rename branch.
	;; archivebr: Tag <branch>, then delete it from the local repository as well as origin. Use to remove old branches that have been incorporated into master, or pass -f to force archiving.
	;; archivelocalbr: Archive all / the first committed N local branches (except for the current branch and master (and base branch if defined)).
	;; archivelocalbrc: Archive all / the first committed N local branches (except for the current branch and master) ordered by date of first commit.
	;; archived: List all / <branch> archived branches.
	;; archivedurl: List URLs to passed <remote> of all / <branch> archived branches.
	archivedourl = archivedurl origin
	archiveduurl = archivedurl upstream
	; How to create an unrelated branch that doesn't hold the previous commit history (e.g. as for the gh-pages)
	; 1. git checkout --orphan gh-pages
	; 2. git rm -rf .
	co = checkout
	checkoutselected = selected-command --filter '' checkout	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to checkout by number.
	cos = checkoutselected
	;; cobr: Checkout passed <remote-branch>, tracking it if it doesn't yet exist locally, or ensuring that an existing tracked branch doesn't contradict the request.
	;; rco: Checkout passed <branch> in <remote>; fetching if needed and ensuring that an existing tracked branch doesn't contradict the request.
	;; rcolatest: Checkout local branch from latest (by sort order) passed <remote> [matching pattern].
	;; rcolatestc: Checkout local branch from the passed <remote> branch [matching pattern] that was created last (except the current branch and master (and base branch if defined)).
	colb = checkout @{-1}	; Checkout last checked-out branch.
	com = master-command checkout
	;; nco: Checkout <branch> and make it the base branch (for git *n commands).
	;; nbr: Show the base branch name.
	;; nclear: Clear the defined base branch.
	con = base-command checkout
	coh = checkout --patch --	; Interactively cherry-pick and check out individual hunks from the index to the working copy.
	detach = checkout --detach	; Unassociate from the current branch without changing the current commit. Useful e.g. for separate worktrees, because they all must be on distinct branches.

	bl = shortblame
	;; file-blame: Show author name and last date for each file.
	;; dirty: Test whether there are uncommitted changes, either in the working copy or the index.
	;; unstaged: Test whether there are / list uncommitted changes to committed files in the working copy (ignoring changes in the index and untracked files).
	;; untracked: Test whether there are new files not yet added to version control (and not covered by the ignore patterns).
	ss = status -s ; Short status without branch and tracking info. Does not output anything if the working copy is clean and there are no untracked files.
	st = status -sb ; Concise status with branch and tracking info.
	;; stfiles: Just list any modified files (for renames both original and resulting file as separate lines).
	;; stifiles: Just list any staged files.
	;; stIfiles: Just list any modified but not staged files.
	;; sti: Concise status only for staged files inside the index.
	;; rbrowse: Open origin / the passed pattern matching a remote in a browser. Like "hub browse", but can open different remotes.

	;; stash: Save a dirty working copy and index in a commit.
	;; stashi: Save only index in a commit; keep the dirty working copy.
	stash-i = stash save --keep-index ; Save only dirty working copy; keep changes in index. Useful to compile / test partial commits by temporarily cleaning the working copy.
	stashuu = stash save --include-untracked	; Save both modified and new (untracked files).
	;; selectedstash: Interactively select from existing stashes (or directly pass N, M, ... selections) to manipulate by number.
	sstash = selectedstash
	;; stashselected: Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to stash by number.
	stashs = stashselected
	stashhunk = stash save --patch	; Interactively cherry-pick and stash away individual hunks changed in the working copy. Keeps changes in index unless --no-keep-index is given.
	;; stash list: Show all stashed commits.
	;; stash apply: Apply the topmost stashed commit onto the working copy.
	;; stash pop: Apply and the topmost stashed commit onto the working copy and remove it from the stash.
	;; stash drop: Remove a single stash.
	;; stash clear: Throw away all stashes.
	; Source: http://stackoverflow.com/questions/1360712/git-stash-cannot-apply-to-a-dirty-working-tree-please-stage-your-changes
	;; stash-pop-to-dirty: Force application of stash to dirty working copy when "stash pop" complains.
	;; stash-to-branch: Stash the changes in a dirty working directory in a new branch.
	;; autostash: Automatically create a temporary stash before executing COMMAND, and apply it after the operation ends. This means that you can run Git commands that otherwise would complain on a dirty worktree.
	;; swaplast: Swap the last and one-before-last commits.

	;; sync: Synchronize the local repository with the major remotes.

	n = notes show ; List annotations for HEAD / passed ref.
	ne = notes edit ; Edit / add annotations for existing commits. They don't change the history, and are local to a repo.
	; Source: http://git-scm.com/blog/2010/08/25/notes.html
	onotepush = push origin refs/notes/* ; notes are implemented as references, and must be pushed to share them.
	unotepush = push upstream refs/notes/* ; notes are implemented as references, and must be pushed to share them.
	onotefetch = fetch origin refs/notes/*:refs/notes/* ; get notes from origin
	unotefetch = fetch upstream refs/notes/*:refs/notes/* ; get notes from upstream
	; To make the fetch automatic, add the following to .git/config:
	; [remote "origin"]
	; 	fetch = +refs/notes/*:refs/notes/*

	; tags how-to:
	;	1. Add a new tag for the newest stable release: git tag -a v0.5 -m "Version 0.5 Stable"
	;	2. Push the latest tag to GitHub: git push --tags
	; Optional:
	;	3. Delete the v0.4 tag locally: git tag -d v0.4
	;	4. Delete the v0.4 tag on GitHub (which removes its download link): git push origin :v0.4
	;; tag-version: Create an annotated tag, mostly used for official releases.

	;; cd: Change into the root directory of this Git working copy.
	root = rev-parse --show-toplevel	; Show root dir of this Git working copy.
	relative = rev-parse --show-prefix	; Show relative dir of the CWD in relation to the Git working copy root.
	; Note: Cannot define this as an external script; the property of being executed in the root dir would be lost.
	;; exec: Execute a shell command in the root dir of this Git working copy; e.g. git exec make.
	; This works because shell aliases are always executed in the top-level directory.
	;; inside: Execute COMMAND (which probably contains Git command(s)) inside the working copy that FILE resides in. (Most Git commands only work from within the working copy.)
	;; wcdo: Execute "git SIMPLECOMMAND" and/or COMMANDLINE on each passed WORKING-COPY.
	;; wc-with-suffix-do: Like wcdo, but also work on clones or worktrees that sit next to the working copy.
	;; wcs-in-dir-do: Execute "git SIMPLECOMMAND" and/or COMMANDLINE on all repositories found in passed DIRSPECs.
	;; wcdo-command: Build a command that executes "git SIMPLECOMMAND" and/or COMMANDLINE on all repositories found in passed wrapper + what + baseDirs.
	;; sh:  Enter a bunch of git commands interactively.
	;; shell: Launch an interactive shell. That alone wouldn't be very interesting, but it's valuable in combination with git-wcdo and the selective invocation based on the provided options.
	serve = !git daemon --reuseaddr --verbose  --base-path=. --export-all ./.git ; Fire up a git daemon for the repo you are currently in.
	;; worktree: Use parallel checkouts of <repository> in <path> (without having to push or pull!)
	; Source: /usr/share/doc/git-core/contrib/workdir/git-new-workdir
	export = archive
	;; export: git export -o latest.zip HEAD
	;; export: git export --format=tar --prefix=project-1.4.0/ v1.4.0 | gzip > project-1.4.0.tar.gz
	;; optimize: Reduce occupied disk space of the GIT_DIR by pruning and then garbage-collecting refs.

	;; whois: Look up person by name or email address.
	;; whodid: Show log grouped by name and sorted by the number of their commits.
	;; whodid -s: Show author names sorted by the number of their commits.
	whodidovertime = pasttimes-command whodid
	whodidoverweeks = pasttimes-command --weekly whodid
	whodidovermonths = pasttimes-command --monthly whodid
	whodidoveryears = pasttimes-command --yearly whodid
	;; whoowns: Show statistics on how many lines were last committed by which author.
	;; whocontributed: Show author names sorted by the total size of the diffs they're responsible for.
	whocontributedovertime = pasttimes-command whocontributed
	whocontributedoverweeks = pasttimes-command --weekly whocontributed
	whocontributedovermonths = pasttimes-command --monthly whocontributed
	whocontributedoveryears = pasttimes-command --yearly whocontributed
	;; churn: Show sorted number of changes per file; arguments as to git log, e.g. --since="1 month ago" subdir
	;; activity: Prints a summary of contributions in the repository.
	activitymine = mine-command activity
	activityteam = team-command activity
	;; logdistribution: Print the distribution of the number of commits that fall into the logged range.
	logdistributionmine = mine-command logdistribution
	logdistributionteam = team-command logdistribution
	whatis = show -s --pretty='tformat:%h (%s, %ad)' --date=short	; Print info about hash or commit name.

	;; customtool: Permanently set / execute remaining arguments with temporary diff.tool / merge.tool set to <toolname>.
	d = diff    ; ... unstaged changes in working copy.
	dt = difftool
	;; diffc: context diff; can also be used as a difftool
	diffy = diffY --suppress-common-lines	; side-by-side diff; can also be used as a difftool
	;; diffY: side-by-side diff of the complete files; can also be used as a difftool
	diffwithdiffc = customtool diff.tool diffc
	diffwithdiffy = customtool diff.tool diffy
	diffwithdiff-y = customtool diff.tool diffY
	;; dl: Show separate diff of each file (instead of concatenating all changes), paged through with less.
	db = diff -w	; ignore all "blanks" whitespace changes
	dbl = dl -w
	dw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words	; use word-based (not line-based) diff granularity
	dc = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=.	; use character-based diff granularity
	da = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]]	; use alnum-based diff granularity
	dy = diffy
	d-y = diffY

	dh = diff HEAD ; ... both staged or unstaged changes since last commit.
	dhl = dl HEAD
	dth = difftool HEAD
	dhw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words HEAD	; use word-based (not line-based) diff granularity
	dhc = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=. HEAD	; use character-based diff granularity
	dha = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]] HEAD	; use alnum-based diff granularity
	dhy = diffy HEAD
	dh-y = diffY HEAD

	dhh = diff HEAD^ ; ... both staged or unstaged changes since second-to-last commit (to check how the commit looks like after adding and amending).
	dhhl = dl HEAD^
	dthh = difftool HEAD^
	dhhw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words HEAD^	; use word-based (not line-based) diff granularity
	dhhc = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=. HEAD^	; use character-based diff granularity
	dhha = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]] HEAD^	; use alnum-based diff granularity
	dhhy = diffy HEAD^
	dhh-y = diffY HEAD^

	dih = diff --cached HEAD^ ; ... only staged changes since second-to-last commit (to check how the commit looks like after amending).
	dihl = dl --cached HEAD^
	dtih = difftool --cached HEAD^
	dihw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --cached HEAD^	; use word-based (not line-based) diff granularity
	dihc = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=. --cached HEAD^	; use character-based diff granularity
	diha = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]] --cached HEAD^	; use alnum-based diff granularity
	dihy = diffy --cached HEAD^
	dih-y = diffY --cached HEAD^

	di = diff --cached ; ... staged changes in the index about to be committed.
	dil = dl --cached
	dti = difftool --cached
	diw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --cached --color-words	; staged changes, use word-based (not line-based) diff granularity
	dic = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --cached --color-words	--word-diff-regex=.	; staged changes, use character-based diff granularity
	dia = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse diff --cached --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]]	; use alnum-based diff granularity
	diy = diffy --cached
	di-y = diffY --cached

	;; dp:  ... with predecessor, either current HEAD or passed revision.
	dpw = dp -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse --color-words	; use word-based (not line-based) diff granularity
	dpc = dp -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse --color-words --word-diff-regex=.	; use character-based diff granularity
	dpa = dp -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]]	; use alnum-based diff granularity
	;; dpl:  ... with predecessor, either current HEAD or passed revision.
	;; dpy:  ... with predecessor, either current HEAD or passed revision.
	;; dpY:  ... with predecessor, either current HEAD or passed revision.

	;; diffcomparep: Compare the diff of unstaged changes in working copy side-by-side with the diff with the predecessor, either current HEAD or passed revision.
	dyp = diffcomparep
	diffcomparepi = diffcomparep --cached ; Compare the diff of unstaged changes in working copy side-by-side with the diff with the predecessor, either current HEAD or passed revision.
	dypi = diffcomparepi
	;
	;; diffuntil: ... over all commits until passed revision.

	;; diffselected: Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to diff by number.
	ds = diffselected
	;; dsw: diffselected with word-based (not line-based) diff granularity
	;; dsc: diffselected with character-based (not line-based) diff granularity
	;; dsa: diffselected with alnum-based diff granularity
	;; dsy: diffselected side-by-side
	;; dsY: diffselected side-by-side
	dis = diffselected --cached
	dts = difftoolselected
	difflastmsg = bylogmessagerange-command --with-log-args diff --auto-revision ; Diff of the last consecutive commit(s) whose messages match the specified text or /regexp/.
	diffmsg = bylogmessagerange-command --with-log-args diff ; Diff from HEAD / the passed -r|--revision REVISION of consecutive commit(s) whose messages match the specified text or /regexp/.

	; Simple patch creation:
	;	$ git diff 1b6d > my.patch
	; On the receiving end, apply via:
	; 	$ git apply my.patch
	;; applycheck: Try to apply the passed patch and print statistics and result.
	;; applyrcheck: Try to apply the passed patch to the root and print statistics and result.
	;; applyr: Apply the patch from the root (as most patches should be based on the toplevel repository directory).
	;
	; Convert commit(s) to a (set of) patches [ <since> | <revision range> ],
	; ready to send by email, by default saved to CWD / -o outdir in mbox
	; format:
	; 	$ git format-patch --stdout 1b6d..HEAD^^
	; which can be passed to git send-email.
	ma = format-patch
	; On the receiving end, save an email to a file, then type:
	; 	$ git am < email.txt
	; Extract commits between revisions R1 and R2, and apply them on top of the current branch using git am to cherry-pick them:
	;   $ git ma -k --stdout R1..R2 | git am -3 -k
	; This applies the incoming patch and also creates a commit, including information such as the author.
	applymbox = am

	g = grep --color -n
	gf = grep --files-with-matches
	g-f = grep --files-without-match

	;; ls: List files under version control; skip unversioned files.
	lsr = ls --recursive
	ll = ls --long --relative-date	; List hash, author, and date of the last commit for each file under source control.
	llr = ls --long --relative-date --recursive
	;; lll: List all files under source control with relative paths from the working copy's root.
	;; lllbrurl: List URLs to passed <remote> of all files under source control in the current branch. In contrast to lllhurl, this link will always point to the latest version on that branch.
	lllbrourl = lllbrurl origin
	lllbruurl = lllbrurl upstream
	;; lllhurl: List URLs to passed <remote> of all files under source control with the current / passed revision. In contrast to lllbrurl (which incorporates future changes done in the branch), this creates a permalink to the current file's contents.
	lllhourl = lllhurl origin
	lllhuurl = lllhurl upstream

	;; datediff: Show the time range of the commits done in the passed <revision-range>, or --since=<date>.

	;; ident-update: Update the expansion of $Id:$ via ident in the .gitattributes after a commit. Can --install a hook to do this automatically on each commit.
	; How to enable what strings:
	; 	1. echo '@(#) file $Id$ project' >> file
	; 	2. echo '* ident' >> .gitattributes
	;   3. git commit file .gitattributes
	;; find-blob: Find commit(s) (the last one is the earliest) which have the passed hash of a blob in their tree. Use to resolve the $Id$ put into a file via the "ident" gitattribute, e.g. in a what string.
	;; hash-object: Print the hash of the passed file (which must not have the $Id$ expanded!)
	; This is the same as
	;   (echo -e -n "blob $(stat -c %s "$file")\0"; cat "$file") | sha1sum

	;; log: Show commit logs, decorate with ref names, show in topological (instead of chronological) order, keeping merged branches together.
	log1 = log --decorate --max-count 1
	log7 = log --decorate --max-count 7

	;; rnlog: Show commit logs, limiting the number counting from the beginning instead of from the end. (You cannot do this via git log --reverse --max-count, because commit limiting is done before commit ordering.)
	;; rnlg: One-line topology, author, date, tags and commit summary, limiting the number counting from the beginning instead of from the end.

	logtimeshifted = discrepancylog --field1 AuthorDate: --field2 CommitDate: --pretty=fuller ; Show logs of amended or rebased commits only.
	logonbehalf = discrepancylog --field1 Author: --field2 Commit: --pretty=fuller	; Show logs where author and committer are not the same person.

	;; logg: Log only those commits where log messages match the specified text or /regexp/.
	loggmine = mine-command logg
	logg1 = logg --max-count 1
	logg7 = logg --max-count 7
	logg1mine = mine-command logg1
	logg7mine = mine-command logg7
	;; lgg: One-line topology, author, date, tags and commit summary where log messages match the specified text or /regexp/.
	lgg1 = lgg --max-count 1
	lgg7 = lgg --max-count 7
	lgg1mine = mine-command lgg1
	lgg7mine = mine-command lgg7

	; findlog does not look at the log message at all, but the actual diff; i.e. those filepairs whose preimage and postimage have different number of occurrences of the text.
	; XXX: Git (2.7.4 on Ubuntu, 2.12 on Windows) somehow has a built-in alias of "pickaxe" to "blame". Because of this, we have to use the shell command syntax !git-pickaxe instead of simply pickaxe.
	findlog = !git-pickaxe	; Pickaxe: Show log of commits where text or /regexp/ was added or removed in the diff.
	findlogmine = mine-command findlog
	findlogv = !git-pickaxe --name-status	; Pickaxe: Show log and filenames of commits where text or /regexp/ was added or removed in the diff.
	findlogvmine = mine-command findlogv
	findlg = !git-pickaxe --abbrev-commit --date=relative --decorate --pretty=oneline ; Pickaxe: Show short log of commits where text or /regexp/ was added or removed in the diff.
	findlgmine = mine-command findlg
	findlc = !GIT_PICKAXE_COMMAND=lc git-pickaxe --date=relative ; Pickaxe: Show log together with diff of commits where text or /regexp/ was added or removed in the diff.
	findlcmine = mine-command findlc
	findlcl = !GIT_PICKAXE_COMMAND=lcl git-pickaxe --date=relative ; Pickaxe: Show separate log together with diff of commits where text or /regexp/ was added or removed in the diff.
	findlclmine = mine-command findlcl
	findshow = !git-pickaxe --max-count 1 --date=relative -p	; Pickaxe: Show short log together with diff of the most recent commit where text or /regexp/ was added or removed in the diff.
	findshowmine = mine-command findshow
	findversions = findcontained findlog annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commits where text or /regexp/ was added or removed in the diff.
	findtags = findcontained findlog describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commits where text or /regexp/ was added or removed in the diff.

	; findlogg looks at both log message and actual diff; a combination of logg and findlog.
	findlogg = pickaxegrep --no-patch	; Show log of commits where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findloggmine = mine-command findlogg
	findloggv = pickaxegrep --name-status	; Show log and filenames of commits where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findloggvmine = mine-command findloggv
	findlgg = pickaxegrep --no-patch --abbrev-commit --date=relative --decorate --pretty=oneline	; Show short log of commits where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findlggmine = mine-command findlgg
	findlcg = pickaxegrep --date=relative	; Show log together with diff of commits where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findlcgmine = mine-command findlcg
	findlclg = !GIT_LOGREVS_SHOW_COMMAND=showl git-pickaxegrep --date=relative	; Show separate log together with diff of commits where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findlclgmine = mine-command findlclg
	findversionsg = findcontained findlogg annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commit where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.
	findtagsg = findcontained findlogg describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commit where log messages match text or /regexp/ or where the text or /regexp/ was added or removed in the diff.

	wherelastlog = !GIT_PICKAXE_COMMAND='log --max-count 1' git-pickaxe	; Show single log of the commit where text or /regexp/ was last mentioned in the diff.
	wherelastlogmine = mine-command wherelastlog
	wherelastlogv = !GIT_PICKAXE_COMMAND='logv --max-count 1' git-pickaxe	; Show single log and filenames of the commit where text or /regexp/ was last mentioned in the diff.
	wherelastlogvmine = mine-command wherelastlogv
	wherelastshow = !git-pickaxe --max-count 1 -p	; Show short log together with diff of the most recent commit where text or /regexp/ was last mentioned in the diff.
	wherelastshowmine = mine-command wherelastshow
	; wherelastshow is like findshow, but without the relative date.
	wherelastversions = findcontained wherelastlog annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commits where text or /regexp/ was last mentioned in the diff.
	wherelasttags = findcontained wherelastlog describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commits where text or /regexp/ was last mentioned in the diff.

	wherelastlogg = pickaxegrep --max-count 1 --no-patch	; Show single log of the commit where text or /regexp/ was last mentioned in the log message or diff.
	wherelastloggmine = mine-command wherelastlogg
	wherelastloggv = pickaxegrep --max-count 1 --name-status	; Show single log and filenames of the commit where text or /regexp/ was last mentioned in the log message or diff.
	wherelastloggvmine = mine-command wherelastloggv
	wherelastshowg = pickaxegrep --max-count 1 --date=relative	; Show single log together with diff of the commit where text or /regexp/ was last mentioned in the log message or diff.
	wherelastshowgmine = mine-command wherelastshowg
	wherelastversionsg = findcontained wherelastlogg annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commit where text or /regexp/ was last mentioned in the log message or diff.
	wherelasttagsg = findcontained wherelastlogg describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commit where text or /regexp/ was last mentioned in the log message or diff.

	whereintroducedlog = !GIT_PICKAXE_COMMAND='rnlog --reverse --max-count 1' git-pickaxe	; Show single log of the commit where text or /regexp/ was first mentioned (added) in the diff.
	whereintroducedlogmine = mine-command whereintroducedlog
	whereintroducedlogv = !GIT_RNLOG_COMMAND=logv GIT_PICKAXE_COMMAND='rnlog --reverse --max-count 1' git-pickaxe	; Show single log including filenames of the commit where text or /regexp/ was first mentioned (added) in the diff.
	whereintroducedlogvmine = mine-command whereintroducedlogv
	whereintroducedshow = !GIT_RNLOG_COMMAND=show GIT_PICKAXE_COMMAND='rnlog --reverse --max-count 1 --date=relative' git-pickaxe	; Show log together with diff of the commit where text or /regexp/ was first mentioned (added) in the diff.
	whereintroducedshowmine = mine-command whereintroducedshow
	whereintroducedversion = findcontained whereintroducedlog annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commit where text or /regexp/ was first mentioned (added) in the diff.
	whereintroducedtag = findcontained whereintroducedlog describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commit where text or /regexp/ was first mentioned (added) in the diff.

	whereintroducedlogg = pickaxegrep --reverse --max-count 1 --no-patch	; Show single log of the commit where text or /regexp/ was first mentioned in the log message or diff.
	whereintroducedloggmine = mine-command whereintroducedlogg
	whereintroducedloggv = pickaxegrep --reverse --max-count 1 --name-status	; Show single log and filenames of the commit where text or /regexp/ was first mentioned in the log message or diff.
	whereintroducedloggvmine = mine-command whereintroducedloggv
	whereintroducedshowg = pickaxegrep --reverse --max-count 1 --date=relative	; Show single log together with diff of the commit where text or /regexp/ was first mentioned in the log message or diff.
	whereintroducedshowgmine = mine-command whereintroducedshowg
	whereintroducedversiong = findcontained whereintroducedlogg annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commit where text or /regexp/ was first mentioned in the log message or diff.
	whereintroducedtagg = findcontained whereintroducedlogg describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commit where text or /regexp/ was first mentioned in the log message or diff.

	; touchedlog is a more encompassing variant of findlog that not just shows those commits where the number of occurrences of text or /regexp/ changes, but also lines matching text or /regexp/ that just were somehow modified, without changing the number of occurrences themselves.
	touchedlog = !git-pickaxe --more	; Pickaxe: Show log where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlogmine = mine-command touchedlog
	touchedlogv = !git-pickaxe --more --name-status	; Pickaxe: Show log and filenames where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlogvmine = mine-command touchedlogv
	touchedlg = !git-pickaxe --more --abbrev-commit --date=relative --decorate --pretty=oneline ; Pickaxe: Show short log where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlgmine = mine-command touchedlg
	touchedlc = !GIT_PICKAXE_COMMAND=lc git-pickaxe --more --date=relative ; Pickaxe: Show log together with diff where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlcmine = mine-command touchedlc
	touchedlcl = !GIT_PICKAXE_COMMAND=lcl git-pickaxe --more --date=relative ; Pickaxe: Show separate log together with diff where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlclmine = mine-command touchedlcl
	touchedshow = !git-pickaxe --more --max-count 1 --date=relative -p	; Pickaxe: Show log together with diff of the most recent commit where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedshowmine = mine-command touchedshow
	touchedversions = findcontained touchedlog annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commits where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedtags = findcontained touchedlog describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commits where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).

	touchedlogg = pickaxegrep --more --no-patch	; Show log of commits where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedloggmine = mine-command touchedlogg
	touchedloggv = pickaxegrep --more --name-status	; Show log and filenames of commits where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedloggvmine = mine-command touchedloggv
	touchedlgg = pickaxegrep --more --no-patch --abbrev-commit --date=relative --decorate --pretty=oneline	; Show short log of commits where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlggmine = mine-command touchedlgg
	touchedlcg = pickaxegrep --more --date=relative	; Show log together with diff of commits where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlcgmine = mine-command touchedlcg
	touchedlclg = !GIT_LOGREVS_SHOW_COMMAND=showl git-pickaxegrep --more --date=relative	; Show separate log together with diff of commits where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedlclgmine = mine-command touchedlclg
	touchedversionsg = findcontained touchedlogg annotated ; Show (only the) first annotated tag (used for official versions etc.) that comes after the commit where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).
	touchedtagsg = findcontained touchedlogg describe ; Show relation to the first tag (also lightweight, used for archiving) that comes after the commit where log messages match text or /regexp/ or where lines were modified where text or /regexp/ appears (without necessarily modifying text or /regexp/ itself).

	lc = whatchanged -m -p ; Logs together with diff between commits.
	lcf = whatchanged -m --first-parent -p ; Logs together with diff between commits, but only from the "main branch" perspective, skipping commits that come from merged branches. This makes sense only when following a strict policy of merging all topic branches when staying on a single integration branch.
	;; lcl: Show separate log and diff of each commit (instead of concatenating all commits), paged through with less. Limit the number of commits via -<number> / -n <number> / --max-count <number> if the default of 20 isn't right.
	lclf = lcl --first-parent
	lcmine = mine-command lc ; Logs together with diff between commits, filtered for my personal commits.
	lcteam = team-command lc ; Logs together with diff between commits, filtered for my team's commits.
	lclastby = dashdash-default-command : others-command byuserrange-command lc --auto-revision : ; Logs together with diff between commits of the last consecutive commit(s) done by the passed or queried user(s)
	lcby = dashdash-default-command : others-command lc : ; Logs together with diff between commits, filtered for that user(s)' commits.
	lcfmine = lcmine --first-parent
	lcfteam = lcteam --first-parent
	lcfby = dashdash-default-command : others-command lc --first-parent :
	lclastmsg = bylogmessagerange-command lc --with-log-args --auto-revision ; Logs together with diff between commits of the last consecutive commit(s) whose messages match the specified text or /regexp/.
	;; show: Log together with diff for a particular commit; like lc but will not log further commits.
	;; showl: Show separate log together with diff of each passed revision (instead of concatenating all commits), paged through with less.
	showw = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse show --color-words	; use word-based (not line-based) diff granularity
	showc = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse show --color-words --word-diff-regex=.	; use character-based diff granularity
	showa = -c color.diff.old=red\\ reverse -c color.diff.new=green\\ reverse show --color-words --word-diff-regex=(^|[^[:alnum:]_])[[:alnum:]_]+([^[:alnum:]_]|$)|[^[:space:]]	; use alnum-based diff granularity
	;; showselected: Log together with diff for the commit interactively chosen from the commits in the passed <range>.
	;; showlselected: Show separate log together with diff for the commit interactively chosen from the commits in the passed <range>.

	showmine = mine-command byuserrange-command show --last-only --auto-revision
	showteam = team-command byuserrange-command show --last-only --auto-revision
	showlastby = dashdash-default-command : others-command byuserrange-command show --last-only --auto-revision :
	showby = dashdash-default-command : others-command show :

	showwmine = mine-command byuserrange-command showw --last-only --auto-revision
	showwteam = team-command byuserrange-command showw --last-only --auto-revision
	showwlastby = dashdash-default-command : others-command byuserrange-command showw --last-only --auto-revision :
	showwby = dashdash-default-command : others-command showw :

	showcmine = mine-command byuserrange-command showc --last-only --auto-revision
	showcteam = team-command byuserrange-command showc --last-only --auto-revision
	showclastby = dashdash-default-command : others-command byuserrange-command showc --last-only --auto-revision :
	showcby = dashdash-default-command : others-command showc :

	showamine = mine-command byuserrange-command showa --last-only --auto-revision
	showateam = team-command byuserrange-command showa --last-only --auto-revision
	showalastby = dashdash-default-command : others-command byuserrange-command showa --last-only --auto-revision :
	showaby = dashdash-default-command : others-command showa :

	;; showfiles: Show the files modified in passed commit or commit range.
	showfilesmine = mine-command byuserrange-command showfiles --last-only --auto-revision	; Show the files modified by me in my last commit.
	showfilesteam = team-command byuserrange-command showfiles --last-only --auto-revision	; Show the files modified by my team in our last commit.
	bymeshowfiles = mine-command byuserrange-command showfiles	; Show all files modified by me in the last / passed -r <commit> and directly preceding, as long as they also were by me.
	byteamshowfiles = team-command byuserrange-command showfiles	; Show all files modified by my team in the last / passed -r <commit> and directly preceding, as long as they also were by them.
	showfind = !GIT_PICKAXE_COMMAND=show git-pickaxe	; Log together with diff of those files where text or /regexp/ was added or removed.
	showfilesfind = !GIT_PICKAXE_COMMAND=showfiles git-pickaxe	; Show the files modified in passed commit or commit range where text or /regexp/ was added or removed.
	showtouched = !GIT_PICKAXE_COMMAND=show git-pickaxe --more	; Log together with diff of those files where lines were modified where text or /regexp/ appears.
	showfilestouched = !GIT_PICKAXE_COMMAND=showfiles git-pickaxe --more	; Show the files modified in passed commit or commit range where lines were modified where text or /regexp/ appears.

	; Commit logs Note: Git 1.6.0 only supports %Cred, %Cgreen, %Cblue for highlighting; only newer Git versions also support %C(more-colors).
	;; logv: Verbose log that includes filenames (like "svn log -v"), and additional committer vs. author information. Still shows all files of the commit even when filtering commits for certain paths (whereas "git log --name-status" also filters the file list itself).
	logv1 = logv --max-count 1
	logv7 = logv --max-count 7
	l = log --pretty=tformat:%s	; One-line list of commit summaries.
	l1 = l --max-count 1
	l7 = l --max-count 7
	lo = log --pretty=format:%B	; Raw, unwrapped subject and body.
	lo1 = show --no-patch --pretty=format:%B	; Raw, unwrapped subject and body, only for the passed commits. Good for reusing for a new commit message.
	lo7 = log --max-count 7 --pretty=format:%B	; Raw, unwrapped subject and body, only for the passed commits. Good for reusing for a new commit message.
	lmine = mine-command l ; git l, filtered for my personal commits.
	lteam = team-command l ; git l, filtered for my team's commits.
	llastby = dashdash-default-command : others-command byuserrange-command l --auto-revision :	; git l of the last consecutive commit(s) done by the passed or queried user(s)
	lby = dashdash-default-command : others-command l : ; git l, filtered for that user(s)' commits.
	lmine1 = lmine --max-count 1
	lmine7 = lmine --max-count 7
	lteam1 = lteam --max-count 1
	lteam7 = lteam --max-count 7
	lothers1 = dashdash-default-command : others-command l --max-count 1 :
	lothers7 = dashdash-default-command : others-command l --max-count 7 :
	llastmsg = bylogmessagerange-command l --with-log-args --auto-revision ; One-line list of commit summaries of the last consecutive commit(s) whose messages match the specified text or /regexp/.
	lg = onelinelog --graph	; One-line topology, author, date, tags and commit summary.
	lg1 = lg --max-count 1
	lg7 = lg --max-count 7

	lgandrefs = onelinelog-and-decorations	; One-line author, date, tags and commit summary for files in <path>, plus any ref names, also of commits not covered.
	lgandtagged = onelinelog-and-decorations --decorate-refs=refs/tags/	; One-line author, date, tags and commit summary for files in <path>, plus any tags, also of commits not covered.
	lgandbr = onelinelog-and-decorations --decorate-refs=refs/heads/	; One-line author, date, tags and commit summary for files in <path>, plus any tips of local branches, also of commits not covered.
	lgandremote = onelinelog-and-decorations --decorate-refs=refs/remotes/	; One-line author, date, tags and commit summary for files in <path>, plus any tips of remote branches, also of commits not covered.
	lgandorigin = onelinelog-and-decorations --decorate-refs=refs/remotes/origin/	; One-line author, date, tags and commit summary for files in <path>, plus any tips of branches in my remote GitHub clone, also of commits not covered.
	lgandupstream = onelinelog-and-decorations --decorate-refs=refs/remotes/upstream/	; One-line author, date, tags and commit summary for files in <path>, plus any tips of upstream branches, also of commits not covered.

	lgtagged = onelinelog-and-decorations --only-decorations --decorate-refs=refs/tags/	; One-line author, date, tags and commit summary for commits that are tagged.
	lgbr = onelinelog-and-decorations --only-decorations --decorate-refs=refs/heads/	; One-line author, date, tips and commit summary for commits that are at the tip of a local branch.
	lgremote = onelinelog-and-decorations --only-decorations --decorate-refs=refs/remotes/	; One-line author, date, tips and commit summary for commits that are at the tip of a remote branch.
	lgorigin = onelinelog-and-decorations --only-decorations --decorate-refs=refs/remotes/origin/	; One-line author, date, tips and commit summary for commits that are at the tip of a branch in my remote GitHub clone.
	lgupstream = onelinelog-and-decorations --only-decorations --decorate-refs=refs/remotes/upstream/	; One-line author, date, tips and commit summary for commits that are at the tip of a branch in upstream.

	;; lgv: One-line author, date, tags and commit summary, followed by modified filenames like "svn log -v".
	lh = log --pretty=tformat:%H	; One-line list of full commit hashes; useful with --grep.
	lh1 = lh --max-count 1	; Same as rev-parse HEAD.
	lh7 = lh --max-count 7	; Same as rev-parse HEAD.
	lhmine = mine-command lh ; git lh, filtered for my personal commits.
	lhteam = team-command lh ; git lh, filtered for my team's commits.
	lhlastby = dashdash-default-command : others-command byuserrange-command lh --auto-revision :	; git lh of the last consecutive commit(s) done by the passed or queried user(s)
	lhby = dashdash-default-command : others-command lh : ; git lh, filtered for that user(s)' commits.
	lhmine1 = lhmine --max-count 1
	lhmine7 = lhmine --max-count 7
	lhteam1 = lhteam --max-count 1
	lhteam7 = lhteam --max-count 7
	lhothers1 = dashdash-default-command : others-command lh --max-count 1 :
	lhothers7 = dashdash-default-command : others-command lh --max-count 7 :
	lhlastmsg = bylogmessagerange-command lh --with-log-args --auto-revision
	;; lurl: URLs to passed <remote> of all found commits.
	lourl = lurl origin	; My GitHub clone URLs of all found commits.
	lourl1 = lourl --max-count 1
	lourl7 = lourl --max-count 7
	luurl = lurl upstream	; Upstream URLs of all found commits.
	luurl1 = luurl --max-count 1
	luurl7 = luurl --max-count 7
	lourlv = lurl origin --name-status	; My GitHub clone URLs and changed files of all found commits.
	lourlv1 = lourlv --max-count 1
	lourlv7 = lourlv --max-count 7
	luurlv = lurl upstream --name-status	; Upstream URLs and changed files of all found commits.
	luurlv1 = luurlv --max-count 1
	luurlv7 = luurlv --max-count 7
	;; treeurl: URLs to passed <remote> of the trees of all found commits.
	treeourl = treeurl origin	; My GitHub clone URLs of the trees of all found commits.
	treeourl1 = treeourl --max-count 1
	treeourl7 = treeourl --max-count 7
	treeuurl = treeurl upstream	; Upstream URLs of the trees of all found commits.
	treeuurl1 = treeuurl --max-count 1
	treeuurl7 = treeuurl --max-count 7
	treeourlv = treeurl origin --name-status	; My GitHub clone URLs of the trees of all found commits and changed files.
	treeourlv1 = treeourlv --max-count 1
	treeourlv7 = treeourlv --max-count 7
	treeuurlv = treeurl upstream --name-status	; Upstream URLs of the trees of all found commits and changed files.
	treeuurlv1 = treeuurlv --max-count 1
	treeuurlv7 = treeuurlv --max-count 7

	;; lghighlight: git lg, with lines that match passed PATTERN highlighted
	lghi = lghighlight
	lghimine = mine-command --no-option-name lghighlight ; git lg, with my personal commits highlighted
	lghiteam = team-command --no-option-name lghighlight ; git lg, with my team's commits highlighted
	lghiby = dashdash-default-command : others-command --name --no-option-name --joined-as-pattern --prefix '(' --suffix ', ' lghighlight : ; git lg, with that user(s)' commits highlighted
	;; lghighlightedcommits: git lg, with commits that result from GIT-LOG-COMMAND (which will be configured to output just commit hashes) highlighted. That argument and GIT-LOG-ARGUMENTS replace a {} marker in GIT-LOG-COMMAND or will be appended.
	;; lghifiles: git lg, with commits that touch the passed <path>s getting highlighted.
	lghist = lghighlightedcommits git\\ logst	; git lg, with commits touching currently modified files highlighted.
	lghii = lghighlightedcommits git\\ logi	; git lg, with commits touching currently staged files highlighted.
	lghi-i = lghighlightedcommits git\\ log-i	; git lg, with commits touching currently modified but not staged files highlighted.
	;; lgghi: git lg, with commits where log messages match the specified text or /regexp/ getting highlighted.

	;; lgmine: git lg, filtered for my personal commits.
	;; lgteam: git lg, filtered for my team's commits.
	lglastby = dashdash-default-command : others-command byuserrange-command lg --auto-revision :	; git lg of the last consecutive commit(s) done by the passed or queried user(s)
	lgby = dashdash-default-command : others-command lg : ; git lg, filtered for that user(s)' commits.
	lgmine1 = lgmine --max-count 1
	lgmine7 = lgmine --max-count 7
	lgteam1 = lgteam --max-count 1
	lgteam7 = lgteam --max-count 7
	lgothers1 = dashdash-default-command : others-command lg --max-count 1 :
	lgothers7 = dashdash-default-command : others-command lg --max-count 7 :
	lglastmsg = bylogmessagerange-command lg --with-log-args --auto-revision
	logmine = mine-command log ; git log, filtered for my personal commits.
	logteam = team-command log ; git log, filtered for my team's commits.
	loglastby = dashdash-default-command : others-command byuserrange-command log --auto-revision :	; git log of the last consecutive commit(s) done by the passed or queried user(s)
	logby = dashdash-default-command : others-command log : ; git log, filtered for that user(s)' commits.
	logmine1 = logmine --max-count 1
	logmine7 = logmine --max-count 7
	logteam1 = logteam --max-count 1
	logteam7 = logteam --max-count 7
	logothers1 = dashdash-default-command : others-command log --max-count 1 :
	logothers7 = dashdash-default-command : others-command log --max-count 7 :
	loglastmsg = bylogmessagerange-command log --with-log-args --auto-revision
	logvmine = mine-command logv ; logmine including filenames
	logvteam = team-command logv ; logteam including filenames
	logvlastby = dashdash-default-command : others-command byuserrange-command logv --auto-revision :	; loglastby including filenames
	logvby = dashdash-default-command : others-command logv : ; logby including filenames
	logvmine1 = logvmine --max-count 1
	logvmine7 = logvmine --max-count 7
	logvteam1 = logvteam --max-count 1
	logvteam7 = logvteam --max-count 7
	logvothers1 = dashdash-default-command : others-command logv --max-count 1 :
	logvothers7 = dashdash-default-command : others-command logv --max-count 7 :
	logvlastmsg = bylogmessagerange-command logv --with-log-args --auto-revision

	lminetoday = today-command mine-command l ; One-line list of commit summaries of my changes of today.
	lteamtoday = today-command team-command l ; One-line list of commit summaries of my team's changes of today.
	lotherstoday = today-command dashdash-default-command : others-command l : ; One-line list of commit summaries of my changes of today.
	lgminetoday = today-command mine-command lg ; One-line topology, author, date, tags and commit summary of my changes of today.
	lgteamtoday = today-command team-command lg ; One-line topology, author, date, tags and commit summary of my team's changes of today.
	lgotherstoday = today-command dashdash-default-command : others-command lg : ; One-line topology, author, date, tags and commit summary of my changes of today.
	logminetoday = today-command mine-command log ; Show log of my changes of today.
	logteamtoday = today-command team-command log ; Show log of my team's changes of today.
	logotherstoday = today-command dashdash-default-command : others-command log : ; Show log of my changes of today.
	logvminetoday = today-command mine-command log --name-status
	logvteamtoday = today-command team-command log --name-status
	logvotherstoday = today-command dashdash-default-command : others-command log --name-status :

	lmineweek = week-command mine-command l ; One-line list of commit summaries of my changes of the previous 7 days.
	lteamweek = week-command team-command l ; One-line list of commit summaries of my team's changes of the previous 7 days.
	lothersweek = week-command dashdash-default-command : others-command l : ; One-line list of commit summaries of my changes of the previous 7 days.
	lgmineweek = week-command mine-command lg ; One-line topology, author, date, tags and commit summary of my changes of the previous 7 days.
	lgteamweek = week-command team-command lg ; One-line topology, author, date, tags and commit summary of my team's changes of the previous 7 days.
	lgothersweek = week-command dashdash-default-command : others-command lg : ; One-line topology, author, date, tags and commit summary of my changes of the previous 7 days.
	logmineweek = week-command mine-command log ; Show log of my changes of the previous 7 days.
	logteamweek = week-command team-command log ; Show log of my team's changes of the previous 7 days.
	logothersweek = week-command dashdash-default-command : others-command log : ; Show log of my changes of the previous 7 days.
	logvmineweek = week-command mine-command log --name-status
	logvteamweek = week-command team-command log --name-status
	logvothersweek = week-command dashdash-default-command : others-command log --name-status :

	lgst = stfiles-command lg	; One-line topology, author, date, tags and commit summary of currently modified files.
	logst = stfiles-command log	; Commit logs of currently modified files.
	logvst = stfiles-command logv	; Verbose commit logs (including filenames) of currently modified files.
	lcst = stfiles-command lc	; Logs together with diff between commits, of currently modified files.

	lgi = stifiles-command lg	; One-line topology, author, date, tags and commit summary of currently staged files.
	logi = stifiles-command log	; Commit logs of currently staged files.
	logvi = stifiles-command logv	; Verbose commit logs (including filenames) of currently staged files.
	lci = stifiles-command lc	; Logs together with diff between commits, of currently staged files.

	lg-i = stIfiles-command lg	; One-line topology, author, date, tags and commit summary of modified but not staged files.
	log-i = stIfiles-command log	; Commit logs of modified but not staged files.
	logv-i = stIfiles-command logv	; Verbose commit logs (including filenames) of modified but not staged files.
	lc-i = stIfiles-command lc	; Logs together with diff between commits, of modified but not staged files.

	lgs = selected-command --filter '' lg	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to log one-line topology, author, date, tags and commit summary by number.
	logs = selected-command --filter '' log	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) commit logs by number.
	logvs = selected-command --filter '' logv	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) verbose commit logs (including filenames) by number.
	lcs = selected-command --filter '' lc	; Interactively select (from modified files or passed list of files) files (or directly pass N, M, ... selections) to log commits together with diff between commits by number.

	emaillg = email-command lg	; Start composing an email with one-line topology, author, date, tags and commit summary output to the originators of the covered commits.
	emaillg1 = email-command lg --max-count 1
	emaillg7 = email-command lg --max-count 7
	emaillog = email-command log	; Start composing an email with log output to the originators of the covered commits.
	emaillog1 = email-command log --max-count 1
	emaillog7 = email-command log --max-count 7
	emaillc = email-command lc	; Start composing an email with logs together with diff output to the originators of the covered commits.
	emailshow = email-command show	; Start composing an email with log + diff output to the originators of the covered commits.

	;; rev-parse: Resolve commit id from various passed ref types.
	;; commitid: Resolve commit id from the passed commit ref, with error message (unless -n|--no-error). With -q|--quiet, just performs the check without any output.
	;; equals: Check whether all passed refs refer to the same commit.

	;; td...: Log variants that only cover changes committed today.
	tdchurn = today-command churn
	tdd = today-command --no-range diffuntil ; Show all changes from today in a single big diff.
	tddl = today-command --no-range diffuntill ; Show all changes from today in a big diffs, separately for each changed file.
	tddt = today-command --no-range difftooluntil ; Show all changes from today in a single big diff.
	tdma = today-command --no-range --one-more format-patch
	tdfindlog = today-command findlog
	tdfindlogv = today-command findlogv
	tdfindlg = today-command findlg
	tdfindlc = today-command findlc
	tdfindlcl = today-command findlcl
	tdfindshow = today-command findshow
	tdfindlogg = today-command findlogg
	tdfindloggv = today-command findloggv
	tdfindlgg = today-command findlgg
	tdfindlcg = today-command findlcg
	tdfindlclg = today-command findlclg
	tdtouchedlog = today-command touchedlog
	tdtouchedlogv = today-command touchedlogv
	tdtouchedlg = today-command touchedlg
	tdtouchedlc = today-command touchedlc
	tdtouchedlcl = today-command touchedlcl
	tdtouchedshow = today-command touchedshow
	tdtouchedlogg = today-command touchedlogg
	tdtouchedloggv = today-command touchedloggv
	tdtouchedlgg = today-command touchedlgg
	tdtouchedlcg = today-command touchedlcg
	tdtouchedlclg = today-command touchedlclg
	tdwherelastlog = today-command wherelastlog
	tdwherelastlogv = today-command wherelastlogv
	tdwherelastshow = today-command wherelastshow
	tdwherelastlogg = today-command wherelastlogg
	tdwherelastloggv = today-command wherelastloggv
	tdwherelastshowg = today-command wherelastshowg
	tdwhereintroducedlog = today-command whereintroducedlog
	tdwhereintroducedlogv = today-command whereintroducedlogv
	tdwhereintroducedshow = today-command whereintroducedshow
	tdwhereintroducedlogg = today-command whereintroducedlogg
	tdwhereintroducedloggv = today-command whereintroducedloggv
	tdwhereintroducedshowg = today-command whereintroducedshowg
	tdlc = today-command lc
	tdlcf = today-command lcf --reverse
	tdlcl = today-command lcl --reverse
	tdlclf = today-command lclf --reverse
	tdlcmine = today-command lcmine --reverse
	tdlcteam = today-command lcteam --reverse
	tdlcby = dashdash-default-command : today-command others-command lc --reverse :
	tdlcfmine = today-command lcfmine --reverse
	tdlcfteam = today-command lcfteam --reverse
	tdlcfby = today-command lcfby --reverse
	tdshow = today-command show
	tdshoww = today-command showw
	tdshowc = today-command showc
	tdshowa = today-command showa
	tdshowfiles = today-command --no-range showfiles
	tdshowselected = today-command showselected
	tdshowlselected = today-command showlselected
	tdlog = today-command log
	tdlogv = today-command logv
	tdglog = today-command glog
	tdlogg = today-command logg
	tdlgg = today-command lgg
	tdl = today-command l
	tdlmine = today-command lmine
	tdlteam = today-command lteam
	tdlby = dashdash-default-command : today-command others-command l :
	tdlg = today-command lg
	tdlgv = today-command lgv
	tdlh = today-command lh --reverse
	tdlhmine = today-command lhmine --reverse
	tdlhteam = today-command lhteam --reverse
	tdlhby = dashdash-default-command : today-command others-command lh --reverse :
	tdlurl = today-command lurl
	tdlourl = today-command lourl --reverse
	tdluurl = today-command luurl --reverse
	tdlourlv = today-command lourlv --reverse
	tdluurlv = today-command luurlv --reverse
	tdtreeurl = today-command treeurl
	tdtreeourl = today-command treeourl --reverse
	tdtreeuurl = today-command treeuurl --reverse
	tdtreeourlv = today-command treeourlv --reverse
	tdtreeuurlv = today-command treeuurlv --reverse
	tdlgmine = today-command lgmine
	tdlgteam = today-command lgteam
	tdlgby = dashdash-default-command : today-command others-command lg :
	tdlogmine = today-command logmine
	tdlogteam = today-command logteam
	tdlogby = dashdash-default-command : today-command others-command log :
	tdrevert = today-command revertselected
	tdrevertcommit = today-command revertcommitselected
	tdcorrect = today-command correctselected
	tdcorrectst = today-command correctst
	tdcorrecti = today-command correcti
	tdcorrect-i = today-command correct-i
	tdfixup = today-command fixupselected
	tdfixupst = today-command fixupst
	tdfixupi = today-command fixupi
	tdfixup-i = today-command fixup-i
	tdrbfixup = today-command rbfixupselected
	tdcommitidentical = today-command commitidenticalselected
	tdcommitidenticalst = today-command commitidenticalst
	tdcommitidenticali = today-command commitidenticali
	tdcommitidentical-i = today-command commitidentical-i
	tdcommitlike = today-command commitlikeselected
	tdcommitlikest = today-command commitlikest
	tdcommitlikei = today-command commitlikei
	tdcommitlike-i = today-command commitlike-i
	tdrbi = today-command --no-range --one-more rebase -i
	tdrbni = today-command --no-range --one-more rbni
	tdwipe = today-command --one-more wipetoselected
	tdbase = today-command --no-range name-rev --name-only
	tdwhodid = files-command whodid tdshowfiles
	tdwhotouched = today-command whodid
	tdwhatdid = today-command whatdid
	; tdactivity would just show activity for today
	; tdactivitymine would just show activity for today
	; tdactivityteam would just show activity for today
	tdlogdistribution = today-command logdistribution
	tdlogdistributionmine = today-command logdistributionmine
	tdlogdistributionteam = today-command logdistributionteam
	tdemaillog = today-command email-command log
	tdemaillc = today-command email-command show
	; tdreintegrate does not cover a branch
	; tdpull-request does not cover a branch

	;; week...: Log variants that only cover changes committed over one week.
	weekchurn = week-command churn
	weekd = week-command --no-range diffuntil ; Show all changes from the last seven days in a single big diff.
	weekdl = week-command --no-range diffuntill ; Show all changes from the last seven days in a big diffs, separately for each changed file.
	weekdt = week-command --no-range difftooluntil ; Show all changes from the last seven days in a single big diff.
	weekma = week-command --no-range --one-more format-patch
	weekfindlog = week-command findlog
	weekfindlogv = week-command findlogv
	weekfindlg = week-command findlg
	weekfindlc = week-command findlc
	weekfindlcl = week-command findlcl
	weekfindshow = week-command findshow
	weekfindlogg = week-command findlogg
	weekfindloggv = week-command findloggv
	weekfindlgg = week-command findlgg
	weekfindlcg = week-command findlcg
	weekfindlclg = week-command findlclg
	weektouchedlog = week-command touchedlog
	weektouchedlogv = week-command touchedlogv
	weektouchedlg = week-command touchedlg
	weektouchedlc = week-command touchedlc
	weektouchedlcl = week-command touchedlcl
	weektouchedshow = week-command touchedshow
	weektouchedlogg = week-command touchedlogg
	weektouchedloggv = week-command touchedloggv
	weektouchedlgg = week-command touchedlgg
	weektouchedlcg = week-command touchedlcg
	weektouchedlclg = week-command touchedlclg
	weekwherelastlog = week-command wherelastlog
	weekwherelastlogv = week-command wherelastlogv
	weekwherelastshow = week-command wherelastshow
	weekwherelastlogg = week-command wherelastlogg
	weekwherelastloggv = week-command wherelastloggv
	weekwherelastshowg = week-command wherelastshowg
	weekwhereintroducedlog = week-command whereintroducedlog
	weekwhereintroducedlogv = week-command whereintroducedlogv
	weekwhereintroducedshow = week-command whereintroducedshow
	weekwhereintroducedlogg = week-command whereintroducedlogg
	weekwhereintroducedloggv = week-command whereintroducedloggv
	weekwhereintroducedshowg = week-command whereintroducedshowg
	weeklc = week-command lc
	weeklcf = week-command lcf --reverse
	weeklcl = week-command lcl --reverse
	weeklclf = week-command lclf --reverse
	weeklcmine = week-command lcmine --reverse
	weeklcteam = week-command lcteam --reverse
	weeklcby = dashdash-default-command : week-command others-command lc --reverse :
	weeklcfmine = week-command lcfmine --reverse
	weeklcfteam = week-command lcfteam --reverse
	weeklcfby = week-command lcfby --reverse
	weekshow = week-command show
	weekshoww = week-command showw
	weekshowc = week-command showc
	weekshowa = week-command showa
	weekshowfiles = week-command --no-range showfiles
	weekshowselected = week-command showselected
	weekshowlselected = week-command showlselected
	weeklog = week-command log
	weeklogv = week-command logv
	weekglog = week-command glog
	weeklogg = week-command logg
	weeklgg = week-command lgg
	weekl = week-command l
	weeklmine = week-command lmine
	weeklteam = week-command lteam
	weeklby = dashdash-default-command : week-command others-command l :
	weeklg = week-command lg
	weeklgv = week-command lgv
	weeklh = week-command lh --reverse
	weeklhmine = week-command lhmine --reverse
	weeklhteam = week-command lhteam --reverse
	weeklhby = dashdash-default-command : week-command others-command lh --reverse :
	weeklurl = week-command lurl
	weeklourl = week-command lourl --reverse
	weekluurl = week-command luurl --reverse
	weeklourlv = week-command lourlv --reverse
	weekluurlv = week-command luurlv --reverse
	weektreeurl = week-command treeurl
	weektreeourl = week-command treeourl --reverse
	weektreeuurl = week-command treeuurl --reverse
	weektreeourlv = week-command treeourlv --reverse
	weektreeuurlv = week-command treeuurlv --reverse
	weeklgmine = week-command lgmine
	weeklgteam = week-command lgteam
	weeklgby = dashdash-default-command : week-command others-command lg :
	weeklogmine = week-command logmine
	weeklogteam = week-command logteam
	weeklogby = dashdash-default-command : week-command others-command log :
	weekrevert = week-command revertselected
	weekrevertcommit = week-command revertcommitselected
	weekcorrect = week-command correctselected
	weekcorrectst = week-command correctst
	weekcorrecti = week-command correcti
	weekcorrect-i = week-command correct-i
	weekfixup = week-command fixupselected
	weekfixupst = week-command fixupst
	weekfixupi = week-command fixupi
	weekfixup-i = week-command fixup-i
	weekrbfixup = week-command rbfixupselected
	weekcommitidentical = week-command commitidenticalselected
	weekcommitidenticalst = week-command commitidenticalst
	weekcommitidenticali = week-command commitidenticali
	weekcommitidentical-i = week-command commitidentical-i
	weekcommitlike = week-command commitlikeselected
	weekcommitlikest = week-command commitlikest
	weekcommitlikei = week-command commitlikei
	weekcommitlike-i = week-command commitlike-i
	weekrbi = week-command --no-range --one-more rebase -i
	weekrbni = week-command --no-range --one-more rbni
	weekwipe = week-command --one-more wipetoselected
	weekbase = week-command --no-range name-rev --name-only
	weekwhodid = files-command whodid weekshowfiles
	weekwhotouched = week-command whodid
	weekwhatdid = week-command whatdid
	; weekactivity would just show activity for the last seven days
	; weekactivitymine would just show activity for the last seven days
	; weekactivityteam would just show activity for the last seven days
	weeklogdistribution = week-command logdistribution
	weeklogdistributionmine = week-command logdistributionmine
	weeklogdistributionteam = week-command logdistributionteam
	weekemaillog = week-command email-command log
	weekemaillc = week-command email-command show
	; weekreintegrate does not cover a branch
	; weekpull-request does not cover a branch

	;; month...: Log variants that only cover changes committed over one month.
	monthchurn = month-command churn
	monthd = month-command --no-range diffuntil ; Show all changes from the last 30/31 days in a single big diff.
	monthdl = month-command --no-range diffuntill ; Show all changes from the last 30/31 days in a big diffs, separately for each changed file.
	monthdt = month-command --no-range difftooluntil ; Show all changes from the last 30/31 days in a single big diff.
	monthma = month-command --no-range --one-more format-patch
	monthfindlog = month-command findlog
	monthfindlogv = month-command findlogv
	monthfindlg = month-command findlg
	monthfindlc = month-command findlc
	monthfindlcl = month-command findlcl
	monthfindshow = month-command findshow
	monthfindlogg = month-command findlogg
	monthfindloggv = month-command findloggv
	monthfindlgg = month-command findlgg
	monthfindlcg = month-command findlcg
	monthfindlclg = month-command findlclg
	monthtouchedlog = month-command touchedlog
	monthtouchedlogv = month-command touchedlogv
	monthtouchedlg = month-command touchedlg
	monthtouchedlc = month-command touchedlc
	monthtouchedlcl = month-command touchedlcl
	monthtouchedshow = month-command touchedshow
	monthtouchedlogg = month-command touchedlogg
	monthtouchedloggv = month-command touchedloggv
	monthtouchedlgg = month-command touchedlgg
	monthtouchedlcg = month-command touchedlcg
	monthtouchedlclg = month-command touchedlclg
	monthwherelastlog = month-command wherelastlog
	monthwherelastlogv = month-command wherelastlogv
	monthwherelastshow = month-command wherelastshow
	monthwherelastlogg = month-command wherelastlogg
	monthwherelastloggv = month-command wherelastloggv
	monthwherelastshowg = month-command wherelastshowg
	monthwhereintroducedlog = month-command whereintroducedlog
	monthwhereintroducedlogv = month-command whereintroducedlogv
	monthwhereintroducedshow = month-command whereintroducedshow
	monthwhereintroducedlogg = month-command whereintroducedlogg
	monthwhereintroducedloggv = month-command whereintroducedloggv
	monthwhereintroducedshowg = month-command whereintroducedshowg
	monthlc = month-command lc
	monthlcf = month-command lcf --reverse
	monthlcl = month-command lcl --reverse
	monthlclf = month-command lclf --reverse
	monthlcmine = month-command lcmine --reverse
	monthlcteam = month-command lcteam --reverse
	monthlcby = dashdash-default-command : month-command others-command lc --reverse :
	monthlcfmine = month-command lcfmine --reverse
	monthlcfteam = month-command lcfteam --reverse
	monthlcfby = month-command lcfby --reverse
	monthshow = month-command show
	monthshoww = month-command showw
	monthshowc = month-command showc
	monthshowa = month-command showa
	monthshowfiles = month-command --no-range showfiles
	monthshowselected = month-command showselected
	monthshowlselected = month-command showlselected
	monthlog = month-command log
	monthlogv = month-command logv
	monthglog = month-command glog
	monthlogg = month-command logg
	monthlgg = month-command lgg
	monthl = month-command l
	monthlmine = month-command lmine
	monthlteam = month-command lteam
	monthlby = dashdash-default-command : month-command others-command l :
	monthlg = month-command lg
	monthlgv = month-command lgv
	monthlh = month-command lh --reverse
	monthlhmine = month-command lhmine --reverse
	monthlhteam = month-command lhteam --reverse
	monthlhby = dashdash-default-command : month-command others-command lh --reverse :
	monthlurl = month-command lurl
	monthlourl = month-command lourl --reverse
	monthluurl = month-command luurl --reverse
	monthlourlv = month-command lourlv --reverse
	monthluurlv = month-command luurlv --reverse
	monthtreeurl = month-command treeurl
	monthtreeourl = month-command treeourl --reverse
	monthtreeuurl = month-command treeuurl --reverse
	monthtreeourlv = month-command treeourlv --reverse
	monthtreeuurlv = month-command treeuurlv --reverse
	monthlgmine = month-command lgmine
	monthlgteam = month-command lgteam
	monthlgby = dashdash-default-command : month-command others-command lg :
	monthlogmine = month-command logmine
	monthlogteam = month-command logteam
	monthlogby = dashdash-default-command : month-command others-command log :
	monthrevert = month-command revertselected
	monthrevertcommit = month-command revertcommitselected
	monthcorrect = month-command correctselected
	monthcorrectst = month-command correctst
	monthcorrecti = month-command correcti
	monthcorrect-i = month-command correct-i
	monthfixup = month-command fixupselected
	monthfixupst = month-command fixupst
	monthfixupi = month-command fixupi
	monthfixup-i = month-command fixup-i
	monthrbfixup = month-command rbfixupselected
	monthcommitidentical = month-command commitidenticalselected
	monthcommitidenticalst = month-command commitidenticalst
	monthcommitidenticali = month-command commitidenticali
	monthcommitidentical-i = month-command commitidentical-i
	monthcommitlike = month-command commitlikeselected
	monthcommitlikest = month-command commitlikest
	monthcommitlikei = month-command commitlikei
	monthcommitlike-i = month-command commitlike-i
	monthrbi = month-command --no-range --one-more rebase -i
	monthrbni = month-command --no-range --one-more rbni
	monthwipe = month-command --one-more wipetoselected
	monthbase = month-command --no-range name-rev --name-only
	monthwhodid = files-command whodid monthshowfiles
	monthwhotouched = month-command whodid
	monthwhatdid = month-command whatdid
	; monthactivity would just show activity for the last 30/31 days
	; monthactivitymine would just show activity for the last 30/31 days
	; monthactivityteam would just show activity for the last 30/31 days
	monthlogdistribution = month-command logdistribution
	monthlogdistributionmine = month-command logdistributionmine
	monthlogdistributionteam = month-command logdistributionteam
	monthemaillog = month-command email-command log
	monthemaillc = month-command email-command show
	; monthreintegrate does not cover a branch
	; monthpull-request does not cover a branch

	;; year...: Log variants that only cover changes committed over one year.
	yearchurn = year-command churn
	yeard = year-command --no-range diffuntil ; Show all changes from the last 365 days in a single big diff.
	yeardl = year-command --no-range diffuntill ; Show all changes from the last 365 days in a big diffs, separately for each changed file.
	yeardt = year-command --no-range difftooluntil ; Show all changes from the last 365 days in a single big diff.
	yearma = year-command --no-range --one-more format-patch
	yearfindlog = year-command findlog
	yearfindlogv = year-command findlogv
	yearfindlg = year-command findlg
	yearfindlc = year-command findlc
	yearfindlcl = year-command findlcl
	yearfindshow = year-command findshow
	yearfindlogg = year-command findlogg
	yearfindloggv = year-command findloggv
	yearfindlgg = year-command findlgg
	yearfindlcg = year-command findlcg
	yearfindlclg = year-command findlclg
	yeartouchedlog = year-command touchedlog
	yeartouchedlogv = year-command touchedlogv
	yeartouchedlg = year-command touchedlg
	yeartouchedlc = year-command touchedlc
	yeartouchedlcl = year-command touchedlcl
	yeartouchedshow = year-command touchedshow
	yeartouchedlogg = year-command touchedlogg
	yeartouchedloggv = year-command touchedloggv
	yeartouchedlgg = year-command touchedlgg
	yeartouchedlcg = year-command touchedlcg
	yeartouchedlclg = year-command touchedlclg
	yearwherelastlog = year-command wherelastlog
	yearwherelastlogv = year-command wherelastlogv
	yearwherelastshow = year-command wherelastshow
	yearwherelastlogg = year-command wherelastlogg
	yearwherelastloggv = year-command wherelastloggv
	yearwherelastshowg = year-command wherelastshowg
	yearwhereintroducedlog = year-command whereintroducedlog
	yearwhereintroducedlogv = year-command whereintroducedlogv
	yearwhereintroducedshow = year-command whereintroducedshow
	yearwhereintroducedlogg = year-command whereintroducedlogg
	yearwhereintroducedloggv = year-command whereintroducedloggv
	yearwhereintroducedshowg = year-command whereintroducedshowg
	yearlc = year-command lc
	yearlcf = year-command lcf --reverse
	yearlcl = year-command lcl --reverse
	yearlclf = year-command lclf --reverse
	yearlcmine = year-command lcmine --reverse
	yearlcteam = year-command lcteam --reverse
	yearlcby = dashdash-default-command : year-command others-command lc --reverse :
	yearlcfmine = year-command lcfmine --reverse
	yearlcfteam = year-command lcfteam --reverse
	yearlcfby = year-command lcfby --reverse
	yearshow = year-command show
	yearshoww = year-command showw
	yearshowc = year-command showc
	yearshowa = year-command showa
	yearshowfiles = year-command --no-range showfiles
	yearshowselected = year-command showselected
	yearshowlselected = year-command showlselected
	yearlog = year-command log
	yearlogv = year-command logv
	yearglog = year-command glog
	yearlogg = year-command logg
	yearlgg = year-command lgg
	yearl = year-command l
	yearlmine = year-command lmine
	yearlteam = year-command lteam
	yearlby = dashdash-default-command : year-command others-command l :
	yearlg = year-command lg
	yearlgv = year-command lgv
	yearlh = year-command lh --reverse
	yearlhmine = year-command lhmine --reverse
	yearlhteam = year-command lhteam --reverse
	yearlhby = dashdash-default-command : year-command others-command lh --reverse :
	yearlurl = year-command lurl
	yearlourl = year-command lourl --reverse
	yearluurl = year-command luurl --reverse
	yearlourlv = year-command lourlv --reverse
	yearluurlv = year-command luurlv --reverse
	yeartreeurl = year-command treeurl
	yeartreeourl = year-command treeourl --reverse
	yeartreeuurl = year-command treeuurl --reverse
	yeartreeourlv = year-command treeourlv --reverse
	yeartreeuurlv = year-command treeuurlv --reverse
	yearlgmine = year-command lgmine
	yearlgteam = year-command lgteam
	yearlgby = dashdash-default-command : year-command others-command lg :
	yearlogmine = year-command logmine
	yearlogteam = year-command logteam
	yearlogby = dashdash-default-command : year-command others-command log :
	yearrevert = year-command revertselected
	yearrevertcommit = year-command revertcommitselected
	yearcorrect = year-command correctselected
	yearcorrectst = year-command correctst
	yearcorrecti = year-command correcti
	yearcorrect-i = year-command correct-i
	yearfixup = year-command fixupselected
	yearfixupst = year-command fixupst
	yearfixupi = year-command fixupi
	yearfixup-i = year-command fixup-i
	yearrbfixup = year-command rbfixupselected
	yearcommitidentical = year-command commitidenticalselected
	yearcommitidenticalst = year-command commitidenticalst
	yearcommitidenticali = year-command commitidenticali
	yearcommitidentical-i = year-command commitidentical-i
	yearcommitlike = year-command commitlikeselected
	yearcommitlikest = year-command commitlikest
	yearcommitlikei = year-command commitlikei
	yearcommitlike-i = year-command commitlike-i
	yearrbi = year-command --no-range --one-more rebase -i
	yearrbni = year-command --no-range --one-more rbni
	yearwipe = year-command --one-more wipetoselected
	yearbase = year-command --no-range name-rev --name-only
	yearwhodid = files-command whodid yearshowfiles
	yearwhotouched = year-command whodid
	yearwhatdid = year-command whatdid
	; yearactivity would just show activity for the last 365 days
	; yearactivitymine would just show activity for the last 365 days
	; yearactivityteam would just show activity for the last 365 days
	yearlogdistribution = year-command logdistribution --final-footer-only
	yearlogdistributionmine = year-command logdistributionmine --final-footer-only
	yearlogdistributionteam = year-command logdistributionteam --final-footer-only
	yearemaillog = year-command email-command log
	yearemaillc = year-command email-command show
	; yearreintegrate does not cover a branch
	; yearpull-request does not cover a branch

	;; by...: Log variants that only cover changes committed by the author of the HEAD / passed -r|--revision REVISION / (with -a|--auto-revision:) the first found revision from the passed --author / --committer(s)
	bychurn = byuserrange-command --with-log-args churn
	byd = byuserrange-command --with-log-args --with-range ... diff
	bydl = byuserrange-command --with-log-args --with-range ... dl
	bydt = byuserrange-command --with-log-args --with-range ... difftool
	byma = byuserrange-command format-patch
	byfindlog = byuserrange-command --with-log-args-except-last findlog
	byfindlogv = byuserrange-command --with-log-args-except-last findlogv
	byfindlg = byuserrange-command --with-log-args-except-last findlg
	byfindlc = byuserrange-command --with-log-args-except-last findlc
	byfindlcl = byuserrange-command --with-log-args-except-last findlcl
	byfindshow = byuserrange-command --with-log-args-except-last findshow
	byfindlogg = byuserrange-command --with-log-args-except-last findlogg
	byfindloggv = byuserrange-command --with-log-args-except-last findloggv
	byfindlgg = byuserrange-command --with-log-args-except-last findlgg
	byfindlcg = byuserrange-command --with-log-args-except-last findlcg
	byfindlclg = byuserrange-command --with-log-args-except-last findlclg
	bytouchedlog = byuserrange-command --with-log-args-except-last touchedlog
	bytouchedlogv = byuserrange-command --with-log-args-except-last touchedlogv
	bytouchedlg = byuserrange-command --with-log-args-except-last touchedlg
	bytouchedlc = byuserrange-command --with-log-args-except-last touchedlc
	bytouchedlcl = byuserrange-command --with-log-args-except-last touchedlcl
	bytouchedshow = byuserrange-command --with-log-args-except-last touchedshow
	bytouchedlogg = byuserrange-command --with-log-args-except-last touchedlogg
	bytouchedloggv = byuserrange-command --with-log-args-except-last touchedloggv
	bytouchedlgg = byuserrange-command --with-log-args-except-last touchedlgg
	bytouchedlcg = byuserrange-command --with-log-args-except-last touchedlcg
	bytouchedlclg = byuserrange-command --with-log-args-except-last touchedlclg
	bywherelastlog = byuserrange-command --with-log-args-except-last wherelastlog
	bywherelastlogv = byuserrange-command --with-log-args-except-last wherelastlogv
	bywherelastshow = byuserrange-command --with-log-args-except-last wherelastshow
	bywherelastlogg = byuserrange-command --with-log-args-except-last wherelastlogg
	bywherelastloggv = byuserrange-command --with-log-args-except-last wherelastloggv
	bywherelastshowg = byuserrange-command --with-log-args-except-last wherelastshowg
	bywhereintroducedlog = byuserrange-command --with-log-args-except-last whereintroducedlog
	bywhereintroducedlogv = byuserrange-command --with-log-args-except-last whereintroducedlogv
	bywhereintroducedshow = byuserrange-command --with-log-args-except-last whereintroducedshow
	bywhereintroducedlogg = byuserrange-command --with-log-args-except-last whereintroducedlogg
	bywhereintroducedloggv = byuserrange-command --with-log-args-except-last whereintroducedloggv
	bywhereintroducedshowg = byuserrange-command --with-log-args-except-last whereintroducedshowg
	bylc = byuserrange-command --with-log-args lc
	bylcf = byuserrange-command --with-log-args lcf --reverse
	bylcl = byuserrange-command --with-log-args lcl --reverse
	bylclf = byuserrange-command --with-log-args lclf --reverse
	bylcmine = byuserrange-command --with-log-args lcmine --reverse
	bylcteam = byuserrange-command --with-log-args lcteam --reverse
	bylcby = dashdash-default-command : byuserrange-command --with-log-args others-command lc --reverse :
	bylcfmine = byuserrange-command --with-log-args lcfmine --reverse
	bylcfteam = byuserrange-command --with-log-args lcfteam --reverse
	bylcfby = byuserrange-command --with-log-args lcfby --reverse
	byshow = byuserrange-command --with-log-args show
	byshoww = byuserrange-command --with-log-args showw
	byshowc = byuserrange-command --with-log-args showc
	byshowa = byuserrange-command --with-log-args showa
	byshowfiles = byuserrange-command --with-log-args --with-range ... showfiles
	byshowselected = byuserrange-command --with-log-args showselected
	byshowlselected = byuserrange-command --with-log-args showlselected
	bylog = byuserrange-command --with-log-args log
	bylogv = byuserrange-command --with-log-args logv
	byglog = byuserrange-command --with-log-args glog
	bylogg = byuserrange-command --with-log-args logg
	bylgg = byuserrange-command --with-log-args lgg
	byl = byuserrange-command --with-log-args l
	bylmine = byuserrange-command --with-log-args lmine
	bylteam = byuserrange-command --with-log-args lteam
	bylby = dashdash-default-command : byuserrange-command --with-log-args others-command l :
	bylg = byuserrange-command --with-log-args lg
	bylgv = byuserrange-command --with-log-args lgv
	bylh = byuserrange-command --with-log-args lh --reverse
	bylhmine = byuserrange-command --with-log-args lhmine --reverse
	bylhteam = byuserrange-command --with-log-args lhteam --reverse
	bylhby = dashdash-default-command : byuserrange-command --with-log-args others-command lh --reverse :
	bylurl = byuserrange-command --with-log-args lurl
	bylourl = byuserrange-command --with-log-args lourl --reverse
	byluurl = byuserrange-command --with-log-args luurl --reverse
	bylourlv = byuserrange-command --with-log-args lourlv --reverse
	byluurlv = byuserrange-command --with-log-args luurlv --reverse
	bytreeurl = byuserrange-command --with-treeog-args treeurl
	bytreeourl = byuserrange-command --with-treeog-args treeourl --reverse
	bytreeuurl = byuserrange-command --with-treeog-args treeuurl --reverse
	bytreeourlv = byuserrange-command --with-treeog-args treeourlv --reverse
	bytreeuurlv = byuserrange-command --with-treeog-args treeuurlv --reverse
	bylgmine = byuserrange-command --with-log-args lgmine
	bylgteam = byuserrange-command --with-log-args lgteam
	bylgby = dashdash-default-command : byuserrange-command --with-log-args others-command lg :
	bylogmine = byuserrange-command --with-log-args logmine
	bylogteam = byuserrange-command --with-log-args logteam
	bylogby = dashdash-default-command : byuserrange-command --with-log-args others-command log :
	byrevert = byuserrange-command revertselected
	byrevertcommit = byuserrange-command revertcommitselected
	bycorrect = byuserrange-command correctselected
	bycorrectst = byuserrange-command correctst
	bycorrecti = byuserrange-command correcti
	bycorrect-i = byuserrange-command correct-i
	byfixup = byuserrange-command fixupselected
	byfixupst = byuserrange-command fixupst
	byfixupi = byuserrange-command fixupi
	byfixup-i = byuserrange-command fixup-i
	byrbfixup = byuserrange-command rbfixupselected
	bycommitidentical = byuserrange-command commitidenticalselected
	bycommitidenticalst = byuserrange-command commitidenticalst
	bycommitidenticali = byuserrange-command commitidenticali
	bycommitidentical-i = byuserrange-command commitidentical-i
	bycommitlike = byuserrange-command commitlikeselected
	bycommitlikest = byuserrange-command commitlikest
	bycommitlikei = byuserrange-command commitlikei
	bycommitlike-i = byuserrange-command commitlike-i
	byrbi = byuserrange-command --no-range --one-more rebase -i
	byrbni = byuserrange-command --no-range --one-more rbni
	bywipe = byuserrange-command --one-more wipetoselected
	bybase = byuserrange-command --no-range name-rev --name-only
	bywhodid = files-command whodid byshowfiles
	bywhotouched = byuserrange-command --with-log-args whodid
	bywhatdid = byuserrange-command --with-log-args whatdid
	byactivity = byuserrange-command --with-log-args activity
	byactivitymine = byuserrange-command --with-log-args activitymine
	byactivityteam = byuserrange-command --with-log-args activityteam
	bylogdistribution = byuserrange-command --with-log-args logdistribution
	bylogdistributionmine = byuserrange-command --with-log-args logdistributionmine
	bylogdistributionteam = byuserrange-command --with-log-args logdistributionteam
	byemaillog = byuserrange-command email-command log
	byemaillc = byuserrange-command email-command lc
	; byreintegrate does not cover a branch
	; bypull-request does not cover a branch

	;; msg...: Log variants that only cover the consecutive commit(s) from the HEAD / passed -r|--revision REVISION / (with -a|--auto-revision:) the first found revision whose messages match the specified text or /regexp/
	msgchurn = bylogmessagerange-command --with-log-args churn
	msgd = bylogmessagerange-command --with-log-args --with-range ... diff	# Same as diffmsg.
	msgdl = bylogmessagerange-command --with-log-args --with-range ... dl
	msgdt = bylogmessagerange-command --with-log-args --with-range ... difftool
	msgma = bylogmessagerange-command format-patch
	msgfindlog = bylogmessagerange-command --with-log-args-except-last findlog
	msgfindlogv = bylogmessagerange-command --with-log-args-except-last findlogv
	msgfindlg = bylogmessagerange-command --with-log-args-except-last findlg
	msgfindlc = bylogmessagerange-command --with-log-args-except-last findlc
	msgfindlcl = bylogmessagerange-command --with-log-args-except-last findlcl
	msgfindshow = bylogmessagerange-command --with-log-args-except-last findshow
	msgfindlogg = bylogmessagerange-command --with-log-args-except-last findlogg
	msgfindloggv = bylogmessagerange-command --with-log-args-except-last findloggv
	msgfindlgg = bylogmessagerange-command --with-log-args-except-last findlgg
	msgfindlcg = bylogmessagerange-command --with-log-args-except-last findlcg
	msgfindlclg = bylogmessagerange-command --with-log-args-except-last findlclg
	msgtouchedlog = bylogmessagerange-command --with-log-args-except-last touchedlog
	msgtouchedlogv = bylogmessagerange-command --with-log-args-except-last touchedlogv
	msgtouchedlg = bylogmessagerange-command --with-log-args-except-last touchedlg
	msgtouchedlc = bylogmessagerange-command --with-log-args-except-last touchedlc
	msgtouchedlcl = bylogmessagerange-command --with-log-args-except-last touchedlcl
	msgtouchedshow = bylogmessagerange-command --with-log-args-except-last touchedshow
	msgtouchedlogg = bylogmessagerange-command --with-log-args-except-last touchedlogg
	msgtouchedloggv = bylogmessagerange-command --with-log-args-except-last touchedloggv
	msgtouchedlgg = bylogmessagerange-command --with-log-args-except-last touchedlgg
	msgtouchedlcg = bylogmessagerange-command --with-log-args-except-last touchedlcg
	msgtouchedlclg = bylogmessagerange-command --with-log-args-except-last touchedlclg
	msgwherelastlog = bylogmessagerange-command --with-log-args-except-last wherelastlog
	msgwherelastlogv = bylogmessagerange-command --with-log-args-except-last wherelastlogv
	msgwherelastshow = bylogmessagerange-command --with-log-args-except-last wherelastshow
	msgwherelastlogg = bylogmessagerange-command --with-log-args-except-last wherelastlogg
	msgwherelastloggv = bylogmessagerange-command --with-log-args-except-last wherelastloggv
	msgwherelastshowg = bylogmessagerange-command --with-log-args-except-last wherelastshowg
	msgwhereintroducedlog = bylogmessagerange-command --with-log-args-except-last whereintroducedlog
	msgwhereintroducedlogv = bylogmessagerange-command --with-log-args-except-last whereintroducedlogv
	msgwhereintroducedshow = bylogmessagerange-command --with-log-args-except-last whereintroducedshow
	msgwhereintroducedlogg = bylogmessagerange-command --with-log-args-except-last whereintroducedlogg
	msgwhereintroducedloggv = bylogmessagerange-command --with-log-args-except-last whereintroducedloggv
	msgwhereintroducedshowg = bylogmessagerange-command --with-log-args-except-last whereintroducedshowg
	msglc = bylogmessagerange-command --with-log-args lc
	msglcf = bylogmessagerange-command --with-log-args lcf --reverse
	msglcl = bylogmessagerange-command --with-log-args lcl --reverse
	msglclf = bylogmessagerange-command --with-log-args lclf --reverse
	msglcmine = bylogmessagerange-command --with-log-args lcmine --reverse
	msglcteam = bylogmessagerange-command --with-log-args lcteam --reverse
	msglcby = dashdash-default-command : bylogmessagerange-command --with-log-args others-command lc --reverse :
	msglcfmine = bylogmessagerange-command --with-log-args lcfmine --reverse
	msglcfteam = bylogmessagerange-command --with-log-args lcfteam --reverse
	msglcfby = bylogmessagerange-command --with-log-args lcfby --reverse
	msgshow = bylogmessagerange-command --with-log-args show
	msgshoww = bylogmessagerange-command --with-log-args showw
	msgshowc = bylogmessagerange-command --with-log-args showc
	msgshowa = bylogmessagerange-command --with-log-args showa
	msgshowfiles = bylogmessagerange-command --with-log-args --with-range ... showfiles
	msgshowselected = bylogmessagerange-command --with-log-args showselected
	msgshowlselected = bylogmessagerange-command --with-log-args showlselected
	msglog = bylogmessagerange-command --with-log-args log
	msglogv = bylogmessagerange-command --with-log-args logv
	msgglog = bylogmessagerange-command --with-log-args glog
	msglogg = bylogmessagerange-command --with-log-args logg
	msglgg = bylogmessagerange-command --with-log-args lgg
	msgl = bylogmessagerange-command --with-log-args l
	msglmine = bylogmessagerange-command --with-log-args lmine
	msglteam = bylogmessagerange-command --with-log-args lteam
	msglby = dashdash-default-command : bylogmessagerange-command --with-log-args others-command l :
	msglg = bylogmessagerange-command --with-log-args lg
	msglgv = bylogmessagerange-command --with-log-args lgv
	msglh = bylogmessagerange-command --with-log-args lh --reverse
	msglhmine = bylogmessagerange-command --with-log-args lhmine --reverse
	msglhteam = bylogmessagerange-command --with-log-args lhteam --reverse
	msglhby = dashdash-default-command : bylogmessagerange-command --with-log-args others-command lh --reverse :
	msglurl = bylogmessagerange-command --with-log-args lurl
	msglourl = bylogmessagerange-command --with-log-args lourl --reverse
	msgluurl = bylogmessagerange-command --with-log-args luurl --reverse
	msglourlv = bylogmessagerange-command --with-log-args lourlv --reverse
	msgluurlv = bylogmessagerange-command --with-log-args luurlv --reverse
	msgtreeurl = bytreeogmessagerange-command --with-treeog-args treeurl
	msgtreeourl = bytreeogmessagerange-command --with-treeog-args treeourl --reverse
	msgtreeuurl = bytreeogmessagerange-command --with-treeog-args treeuurl --reverse
	msgtreeourlv = bytreeogmessagerange-command --with-treeog-args treeourlv --reverse
	msgtreeuurlv = bytreeogmessagerange-command --with-treeog-args treeuurlv --reverse
	msglgmine = bylogmessagerange-command --with-log-args lgmine
	msglgteam = bylogmessagerange-command --with-log-args lgteam
	msglgby = dashdash-default-command : bylogmessagerange-command --with-log-args others-command lg :
	msglogmine = bylogmessagerange-command --with-log-args logmine
	msglogteam = bylogmessagerange-command --with-log-args logteam
	msglogby = dashdash-default-command : bylogmessagerange-command --with-log-args others-command log :
	msgrevert = bylogmessagerange-command revertselected
	msgrevertcommit = bylogmessagerange-command revertcommitselected
	msgcorrect = bylogmessagerange-command correctselected
	msgcorrectst = bylogmessagerange-command correctst
	msgcorrecti = bylogmessagerange-command correcti
	msgcorrect-i = bylogmessagerange-command correct-i
	msgfixup = bylogmessagerange-command fixupselected
	msgfixupst = bylogmessagerange-command fixupst
	msgfixupi = bylogmessagerange-command fixupi
	msgfixup-i = bylogmessagerange-command fixup-i
	msgrbfixup = bylogmessagerange-command rbfixupselected
	msgcommitidentical = bylogmessagerange-command commitidenticalselected
	msgcommitidenticalst = bylogmessagerange-command commitidenticalst
	msgcommitidenticali = bylogmessagerange-command commitidenticali
	msgcommitidentical-i = bylogmessagerange-command commitidentical-i
	msgcommitlike = bylogmessagerange-command commitlikeselected
	msgcommitlikest = bylogmessagerange-command commitlikest
	msgcommitlikei = bylogmessagerange-command commitlikei
	msgcommitlike-i = bylogmessagerange-command commitlike-i
	msgrbi = bylogmessagerange-command --no-range --one-more rebase -i
	msgrbni = bylogmessagerange-command --no-range --one-more rbni
	msgwipe = bylogmessagerange-command --one-more wipetoselected
	msgbase = bylogmessagerange-command --no-range name-rev --name-only
	msgwhodid = files-command whodid byshowfiles
	msgwhotouched = bylogmessagerange-command --with-log-args whodid
	msgwhatdid = bylogmessagerange-command --with-log-args whatdid
	msgactivity = bylogmessagerange-command --with-log-args activity
	msgactivitymine = bylogmessagerange-command --with-log-args activitymine
	msgactivityteam = bylogmessagerange-command --with-log-args activityteam
	msglogdistribution = bylogmessagerange-command --with-log-args logdistribution
	msglogdistributionmine = bylogmessagerange-command --with-log-args logdistributionmine
	msglogdistributionteam = bylogmessagerange-command --with-log-args logdistributionteam
	msgemaillog = bylogmessagerange-command email-command log
	msgemaillc = bylogmessagerange-command email-command lc
	; msgreintegrate does not cover a branch
	; msgpull-request does not cover a branch

	;; lastmsg...: Log variants that only cover the last consecutive commit(s) whose messages match the specified text or /regexp/.
	lastmsgchurn = bylogmessagerange-command --with-log-args --auto-revision churn
	lastmsgd = bylogmessagerange-command --with-log-args --auto-revision --with-range ... diff	# Same as difflastmsg.
	lastmsgdl = bylogmessagerange-command --with-log-args --auto-revision --with-range ... dl
	lastmsgdt = bylogmessagerange-command --with-log-args --auto-revision --with-range ... difftool
	lastmsgma = bylogmessagerange-command --auto-revision format-patch
	lastmsgfindlog = bylogmessagerange-command --with-log-args-except-last --auto-revision findlog
	lastmsgfindlogv = bylogmessagerange-command --with-log-args-except-last --auto-revision findlogv
	lastmsgfindlg = bylogmessagerange-command --with-log-args-except-last --auto-revision findlg
	lastmsgfindlc = bylogmessagerange-command --with-log-args-except-last --auto-revision findlc
	lastmsgfindlcl = bylogmessagerange-command --with-log-args-except-last --auto-revision findlcl
	lastmsgfindshow = bylogmessagerange-command --with-log-args-except-last --auto-revision findshow
	lastmsgfindlogg = bylogmessagerange-command --with-log-args-except-last --auto-revision findlogg
	lastmsgfindloggv = bylogmessagerange-command --with-log-args-except-last --auto-revision findloggv
	lastmsgfindlgg = bylogmessagerange-command --with-log-args-except-last --auto-revision findlgg
	lastmsgfindlcg = bylogmessagerange-command --with-log-args-except-last --auto-revision findlcg
	lastmsgfindlclg = bylogmessagerange-command --with-log-args-except-last --auto-revision findlclg
	lastmsgtouchedlog = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlog
	lastmsgtouchedlogv = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlogv
	lastmsgtouchedlg = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlg
	lastmsgtouchedlc = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlc
	lastmsgtouchedlcl = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlcl
	lastmsgtouchedshow = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedshow
	lastmsgtouchedlogg = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlogg
	lastmsgtouchedloggv = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedloggv
	lastmsgtouchedlgg = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlgg
	lastmsgtouchedlcg = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlcg
	lastmsgtouchedlclg = bylogmessagerange-command --with-log-args-except-last --auto-revision touchedlclg
	lastmsgwherelastlog = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastlog
	lastmsgwherelastlogv = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastlogv
	lastmsgwherelastshow = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastshow
	lastmsgwherelastlogg = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastlogg
	lastmsgwherelastloggv = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastloggv
	lastmsgwherelastshowg = bylogmessagerange-command --with-log-args-except-last --auto-revision wherelastshowg
	lastmsgwhereintroducedlog = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedlog
	lastmsgwhereintroducedlogv = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedlogv
	lastmsgwhereintroducedshow = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedshow
	lastmsgwhereintroducedlogg = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedlogg
	lastmsgwhereintroducedloggv = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedloggv
	lastmsgwhereintroducedshowg = bylogmessagerange-command --with-log-args-except-last --auto-revision whereintroducedshowg
	lastmsglc = bylogmessagerange-command --with-log-args --auto-revision lc	# Same as lcmastmsg.
	lastmsglcf = bylogmessagerange-command --with-log-args --auto-revision lcf --reverse
	lastmsglcl = bylogmessagerange-command --with-log-args --auto-revision lcl --reverse
	lastmsglclf = bylogmessagerange-command --with-log-args --auto-revision lclf --reverse
	lastmsglcmine = bylogmessagerange-command --with-log-args --auto-revision lcmine --reverse
	lastmsglcteam = bylogmessagerange-command --with-log-args --auto-revision lcteam --reverse
	lastmsglcby = dashdash-default-command : bylogmessagerange-command --with-log-args --auto-revision others-command lc --reverse :
	lastmsglcfmine = bylogmessagerange-command --with-log-args --auto-revision lcfmine --reverse
	lastmsglcfteam = bylogmessagerange-command --with-log-args --auto-revision lcfteam --reverse
	lastmsglcfby = bylogmessagerange-command --with-log-args --auto-revision lcfby --reverse
	lastmsgshow = bylogmessagerange-command --with-log-args --auto-revision show
	lastmsgshoww = bylogmessagerange-command --with-log-args --auto-revision showw
	lastmsgshowc = bylogmessagerange-command --with-log-args --auto-revision showc
	lastmsgshowa = bylogmessagerange-command --with-log-args --auto-revision showa
	lastmsgshowfiles = bylogmessagerange-command --with-log-args --auto-revision --with-range ... showfiles
	lastmsgshowselected = bylogmessagerange-command --with-log-args --auto-revision showselected
	lastmsgshowlselected = bylogmessagerange-command --with-log-args --auto-revision showlselected
	lastmsglog = bylogmessagerange-command --with-log-args --auto-revision log	# Same as loglastmsg.
	lastmsglogv = bylogmessagerange-command --with-log-args --auto-revision logv	# Same as logvlastmsg.
	lastmsgglog = bylogmessagerange-command --with-log-args --auto-revision glog
	lastmsglogg = bylogmessagerange-command --with-log-args --auto-revision logg
	lastmsglgg = bylogmessagerange-command --with-log-args --auto-revision lgg
	lastmsgl = bylogmessagerange-command --with-log-args --auto-revision l	# Same as llastmsg.
	lastmsglmine = bylogmessagerange-command --with-log-args --auto-revision lmine
	lastmsglteam = bylogmessagerange-command --with-log-args --auto-revision lteam
	lastmsglby = dashdash-default-command : bylogmessagerange-command --with-log-args --auto-revision others-command l :
	lastmsglg = bylogmessagerange-command --with-log-args --auto-revision lg	# Same as lglastmsg.
	lastmsglgv = bylogmessagerange-command --with-log-args --auto-revision lgv
	lastmsglh = bylogmessagerange-command --with-log-args --auto-revision lh --reverse	# Same as lhlastmsg.
	lastmsglhmine = bylogmessagerange-command --with-log-args --auto-revision lhmine --reverse
	lastmsglhteam = bylogmessagerange-command --with-log-args --auto-revision lhteam --reverse
	lastmsglhby = dashdash-default-command : bylogmessagerange-command --with-log-args --auto-revision others-command lh --reverse :
	lastmsglurl = bylogmessagerange-command --with-log-args --auto-revision lurl
	lastmsglourl = bylogmessagerange-command --with-log-args --auto-revision lourl --reverse
	lastmsgluurl = bylogmessagerange-command --with-log-args --auto-revision luurl --reverse
	lastmsglourlv = bylogmessagerange-command --with-log-args --auto-revision lourlv --reverse
	lastmsgluurlv = bylogmessagerange-command --with-log-args --auto-revision luurlv --reverse
	lastmsgtreeurl = bytreeogmessagerange-command --with-treeog-args --auto-revision treeurl
	lastmsgtreeourl = bytreeogmessagerange-command --with-treeog-args --auto-revision treeourl --reverse
	lastmsgtreeuurl = bytreeogmessagerange-command --with-treeog-args --auto-revision treeuurl --reverse
	lastmsgtreeourlv = bytreeogmessagerange-command --with-treeog-args --auto-revision treeourlv --reverse
	lastmsgtreeuurlv = bytreeogmessagerange-command --with-treeog-args --auto-revision treeuurlv --reverse
	lastmsglgmine = bylogmessagerange-command --with-log-args --auto-revision lgmine
	lastmsglgteam = bylogmessagerange-command --with-log-args --auto-revision lgteam
	lastmsglgby = dashdash-default-command : bylogmessagerange-command --with-log-args --auto-revision others-command lg :
	lastmsglogmine = bylogmessagerange-command --with-log-args --auto-revision logmine
	lastmsglogteam = bylogmessagerange-command --with-log-args --auto-revision logteam
	lastmsglogby = dashdash-default-command : bylogmessagerange-command --with-log-args --auto-revision others-command log :
	lastmsgrevert = bylogmessagerange-command --auto-revision revertselected
	lastmsgrevertcommit = bylogmessagerange-command --auto-revision revertcommitselected
	lastmsgcorrect = bylogmessagerange-command --auto-revision correctselected
	lastmsgcorrectst = bylogmessagerange-command --auto-revision correctst
	lastmsgcorrecti = bylogmessagerange-command --auto-revision correcti
	lastmsgcorrect-i = bylogmessagerange-command --auto-revision correct-i
	lastmsgfixup = bylogmessagerange-command --auto-revision fixupselected
	lastmsgfixupst = bylogmessagerange-command --auto-revision fixupst
	lastmsgfixupi = bylogmessagerange-command --auto-revision fixupi
	lastmsgfixup-i = bylogmessagerange-command --auto-revision fixup-i
	lastmsgrbfixup = bylogmessagerange-command --auto-revision rbfixupselected
	lastmsgcommitidentical = bylogmessagerange-command --auto-revision commitidenticalselected
	lastmsgcommitidenticalst = bylogmessagerange-command --auto-revision commitidenticalst
	lastmsgcommitidenticali = bylogmessagerange-command --auto-revision commitidenticali
	lastmsgcommitidentical-i = bylogmessagerange-command --auto-revision commitidentical-i
	lastmsgcommitlike = bylogmessagerange-command --auto-revision commitlikeselected
	lastmsgcommitlikest = bylogmessagerange-command --auto-revision commitlikest
	lastmsgcommitlikei = bylogmessagerange-command --auto-revision commitlikei
	lastmsgcommitlike-i = bylogmessagerange-command --auto-revision commitlike-i
	lastmsgrbi = bylogmessagerange-command --auto-revision --no-range --one-more rebase -i
	lastmsgrbni = bylogmessagerange-command --auto-revision --no-range --one-more rbni
	lastmsgwipe = bylogmessagerange-command --auto-revision --one-more wipetoselected
	lastmsgbase = bylogmessagerange-command --auto-revision --no-range name-rev --name-only
	lastmsgwhodid = files-command whodid byshowfiles
	lastmsgwhotouched = bylogmessagerange-command --with-log-args --auto-revision whodid
	lastmsgwhatdid = bylogmessagerange-command --with-log-args --auto-revision whatdid
	lastmsgactivity = bylogmessagerange-command --with-log-args --auto-revision activity
	lastmsgactivitymine = bylogmessagerange-command --with-log-args --auto-revision activitymine
	lastmsgactivityteam = bylogmessagerange-command --with-log-args --auto-revision activityteam
	lastmsglogdistribution = bylogmessagerange-command --with-log-args --auto-revision logdistribution
	lastmsglogdistributionmine = bylogmessagerange-command --with-log-args --auto-revision logdistributionmine
	lastmsglogdistributionteam = bylogmessagerange-command --with-log-args --auto-revision logdistributionteam
	lastmsgemaillog = bylogmessagerange-command --auto-revision email-command log
	lastmsgemaillc = bylogmessagerange-command --auto-revision email-command lc
	; lastmsgreintegrate does not cover a branch
	; lastmsgpull-request does not cover a branch

	;; rev-range: Run a Git command with a revision range from the passed revision up to HEAD.
	;; rev-range-this-branch: Run a Git command with a revision range that covers the current / passed via -b|--branch branch (up to another reference).
	;; rev-range-incoming: Run a Git command with the revision range of the commits that already exist in remote on the current branch, but not yet in the local branch.
	;; rev-range-outgoing: Run a Git command with the revision range of the commits that already exist on the current branch, but not yet in the corresponding remote branch.

	;; br...: Log variants that only cover the current / passed via -b|--branch branch (as tagged or referenced anywhere in the history (also by remotes))
	brchurn = rev-range-this-branch --any churn
	brd = rev-range-this-branch --any --with-range ... diff
	brdl = rev-range-this-branch --any --with-range ... dl
	brdt = rev-range-this-branch --any --with-range ... difftool
	brma = rev-range-this-branch --any format-patch
	brfindlog = rev-range-this-branch --any --keep-last findlog
	brfindlogv = rev-range-this-branch --any --keep-last findlogv
	brfindlg = rev-range-this-branch --any --keep-last findlg
	brfindlc = rev-range-this-branch --any --keep-last findlc
	brfindlcl = rev-range-this-branch --any --keep-last findlcl
	brfindshow = rev-range-this-branch --any --keep-last findshow
	brfindlogg = rev-range-this-branch --any --keep-last findlogg
	brfindloggv = rev-range-this-branch --any --keep-last findloggv
	brfindlgg = rev-range-this-branch --any --keep-last findlgg
	brfindlcg = rev-range-this-branch --any --keep-last findlcg
	brfindlclg = rev-range-this-branch --any --keep-last findlclg
	brtouchedlog = rev-range-this-branch --any --keep-last touchedlog
	brtouchedlogv = rev-range-this-branch --any --keep-last touchedlogv
	brtouchedlg = rev-range-this-branch --any --keep-last touchedlg
	brtouchedlc = rev-range-this-branch --any --keep-last touchedlc
	brtouchedlcl = rev-range-this-branch --any --keep-last touchedlcl
	brtouchedshow = rev-range-this-branch --any --keep-last touchedshow
	brtouchedlogg = rev-range-this-branch --any --keep-last touchedlogg
	brtouchedloggv = rev-range-this-branch --any --keep-last touchedloggv
	brtouchedlgg = rev-range-this-branch --any --keep-last touchedlgg
	brtouchedlcg = rev-range-this-branch --any --keep-last touchedlcg
	brtouchedlclg = rev-range-this-branch --any --keep-last touchedlclg
	brwherelastlog = rev-range-this-branch --any --keep-last wherelastlog
	brwherelastlogv = rev-range-this-branch --any --keep-last wherelastlogv
	brwherelastshow = rev-range-this-branch --any --keep-last wherelastshow
	brwherelastlogg = rev-range-this-branch --any --keep-last wherelastlogg
	brwherelastloggv = rev-range-this-branch --any --keep-last wherelastloggv
	brwherelastshowg = rev-range-this-branch --any --keep-last wherelastshowg
	brwhereintroducedlog = rev-range-this-branch --any --keep-last whereintroducedlog
	brwhereintroducedlogv = rev-range-this-branch --any --keep-last whereintroducedlogv
	brwhereintroducedshow = rev-range-this-branch --any --keep-last whereintroducedshow
	brwhereintroducedlogg = rev-range-this-branch --any --keep-last whereintroducedlogg
	brwhereintroducedloggv = rev-range-this-branch --any --keep-last whereintroducedloggv
	brwhereintroducedshowg = rev-range-this-branch --any --keep-last whereintroducedshowg
	brlc = rev-range-this-branch --any --one-more-command log --one-more-with-padding lc
	brlcf = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcf --reverse
	brlcl = rev-range-this-branch --any lcl --reverse
	brlclf = rev-range-this-branch --any lclf --reverse
	brlcmine = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcmine --reverse
	brlcteam = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcteam --reverse
	brlcby = dashdash-default-command : rev-range-this-branch --any --one-more-command log --one-more-with-padding others-command lc --reverse :
	brlcfmine = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcfmine --reverse
	brlcfteam = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcfteam --reverse
	brlcfby = rev-range-this-branch --any --one-more-command log --one-more-with-padding lcfby --reverse
	brshow = rev-range-this-branch --any --one-more-command log --one-more-with-padding show
	brshoww = rev-range-this-branch --any --one-more-command log --one-more-with-padding showw
	brshowc = rev-range-this-branch --any --one-more-command log --one-more-with-padding showc
	brshowa = rev-range-this-branch --any --one-more-command log --one-more-with-padding showa
	brshowfiles = rev-range-this-branch --any --with-range ... showfiles
	brshowselected = rev-range-this-branch --any --one-more-command log --one-more-with-padding showselected
	brshowlselected = rev-range-this-branch --any --one-more-command log --one-more-with-padding showlselected
	brlog = rev-range-this-branch --any --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	brlogv = rev-range-this-branch --any --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	brglog = rev-range-this-branch --any glog
	brlogg = rev-range-this-branch --any --keep-last logg
	brlgg = rev-range-this-branch --any --keep-last lgg
	brl = rev-range-this-branch --any l
	brlmine = rev-range-this-branch --any lmine
	brlteam = rev-range-this-branch --any lteam
	brlby = dashdash-default-command : rev-range-this-branch --any others-command l :
	brlg = rev-range-this-branch --any --one-more-command greyonelinelog --one-more-only-to-terminal lg
	brlgn = rev-range-this-branch --any lg
	brlgv = rev-range-this-branch --any --one-more lgv
	brlh = rev-range-this-branch --any lh --reverse
	brlhmine = rev-range-this-branch --any lhmine --reverse
	brlhteam = rev-range-this-branch --any lhteam --reverse
	brlhby = dashdash-default-command : rev-range-this-branch --any others-command lh --reverse :
	brlurl = rev-range-this-branch --any lurl
	brlourl = rev-range-this-branch --any lourl --reverse
	brluurl = rev-range-this-branch --any luurl --reverse
	brlourlv = rev-range-this-branch --any lourlv --reverse
	brluurlv = rev-range-this-branch --any luurlv --reverse
	brtreeurl = rev-range-this-branch --any treeurl
	brtreeourl = rev-range-this-branch --any treeourl --reverse
	brtreeuurl = rev-range-this-branch --any treeuurl --reverse
	brtreeourlv = rev-range-this-branch --any treeourlv --reverse
	brtreeuurlv = rev-range-this-branch --any treeuurlv --reverse
	brlgmine = rev-range-this-branch --any --one-more lgmine
	brlgteam = rev-range-this-branch --any --one-more lgteam
	brlgby = dashdash-default-command : rev-range-this-branch --any --one-more others-command lg :
	brlogmine = rev-range-this-branch --any --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	brlogteam = rev-range-this-branch --any --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	brlogby = dashdash-default-command : rev-range-this-branch --any --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	brrevert = rev-range-this-branch --any revertselected
	brrevertcommit = rev-range-this-branch --any revertcommitselected
	brcorrect = rev-range-this-branch --any correctselected
	brcorrectst = rev-range-this-branch --any correctst
	brcorrecti = rev-range-this-branch --any correcti
	brcorrect-i = rev-range-this-branch --any correct-i
	brfixup = rev-range-this-branch --any fixupselected
	brfixupst = rev-range-this-branch --any fixupst
	brfixupi = rev-range-this-branch --any fixupi
	brfixup-i = rev-range-this-branch --any fixup-i
	brrbfixup = rev-range-this-branch --any rbfixupselected
	brcommitidentical = rev-range-this-branch --any commitidenticalselected
	brcommitidenticalst = rev-range-this-branch --any commitidenticalst
	brcommitidenticali = rev-range-this-branch --any commitidenticali
	brcommitidentical-i = rev-range-this-branch --any commitidentical-i
	brcommitlike = rev-range-this-branch --any commitlikeselected
	brcommitlikest = rev-range-this-branch --any commitlikest
	brcommitlikei = rev-range-this-branch --any commitlikei
	brcommitlike-i = rev-range-this-branch --any commitlike-i
	brrbi = rev-range-this-branch --any --no-range rebase -i
	brrbni = rev-range-this-branch --any --no-range rbni
	brwipe = rev-range-this-branch --any wipetoselected
	brbase = rev-range-this-branch --any --no-range name-rev --name-only
	brwhodid = files-command whodid brshowfiles
	brwhotouched = rev-range-this-branch --any whodid
	brwhatdid = rev-range-this-branch --any whatdid
	bractivity = rev-range-this-branch --any activity
	bractivitymine = rev-range-this-branch --any activitymine
	bractivityteam = rev-range-this-branch --any activityteam
	brlogdistribution = rev-range-this-branch --any logdistribution
	brlogdistributionmine = rev-range-this-branch --any logdistributionmine
	brlogdistributionteam = rev-range-this-branch --any logdistributionteam
	bremaillog = rev-range-this-branch --any email-command log
	bremaillc = rev-range-this-branch --any email-command lc
	brreintegrate = previousbranch-command --keep-position reintegrateto --branch BRANCH
	brpull-request = previousbranch-command --keep-position pull-request --base BRANCH

	;; b2r...: Log variants that only cover the current / passed via -b|--branch and preceding branch (as tagged or referenced anywhere in the history (also by remotes))
	b2rchurn = rev-range-this-branch --any --branch-number 2 churn
	b2rd = rev-range-this-branch --any --branch-number 2 --with-range ... diff
	b2rdl = rev-range-this-branch --any --branch-number 2 --with-range ... dl
	b2rdt = rev-range-this-branch --any --branch-number 2 --with-range ... difftool
	b2rma = rev-range-this-branch --any --branch-number 2 format-patch
	b2rfindlog = rev-range-this-branch --any --branch-number 2 --keep-last findlog
	b2rfindlogv = rev-range-this-branch --any --branch-number 2 --keep-last findlogv
	b2rfindlg = rev-range-this-branch --any --branch-number 2 --keep-last findlg
	b2rfindlc = rev-range-this-branch --any --branch-number 2 --keep-last findlc
	b2rfindlcl = rev-range-this-branch --any --branch-number 2 --keep-last findlcl
	b2rfindshow = rev-range-this-branch --any --branch-number 2 --keep-last findshow
	b2rfindlogg = rev-range-this-branch --any --branch-number 2 --keep-last findlogg
	b2rfindloggv = rev-range-this-branch --any --branch-number 2 --keep-last findloggv
	b2rfindlgg = rev-range-this-branch --any --branch-number 2 --keep-last findlgg
	b2rfindlcg = rev-range-this-branch --any --branch-number 2 --keep-last findlcg
	b2rfindlclg = rev-range-this-branch --any --branch-number 2 --keep-last findlclg
	b2rtouchedlog = rev-range-this-branch --any --branch-number 2 --keep-last touchedlog
	b2rtouchedlogv = rev-range-this-branch --any --branch-number 2 --keep-last touchedlogv
	b2rtouchedlg = rev-range-this-branch --any --branch-number 2 --keep-last touchedlg
	b2rtouchedlc = rev-range-this-branch --any --branch-number 2 --keep-last touchedlc
	b2rtouchedlcl = rev-range-this-branch --any --branch-number 2 --keep-last touchedlcl
	b2rtouchedshow = rev-range-this-branch --any --branch-number 2 --keep-last touchedshow
	b2rtouchedlogg = rev-range-this-branch --any --branch-number 2 --keep-last touchedlogg
	b2rtouchedloggv = rev-range-this-branch --any --branch-number 2 --keep-last touchedloggv
	b2rtouchedlgg = rev-range-this-branch --any --branch-number 2 --keep-last touchedlgg
	b2rtouchedlcg = rev-range-this-branch --any --branch-number 2 --keep-last touchedlcg
	b2rtouchedlclg = rev-range-this-branch --any --branch-number 2 --keep-last touchedlclg
	b2rwherelastlog = rev-range-this-branch --any --branch-number 2 --keep-last wherelastlog
	b2rwherelastlogv = rev-range-this-branch --any --branch-number 2 --keep-last wherelastlogv
	b2rwherelastshow = rev-range-this-branch --any --branch-number 2 --keep-last wherelastshow
	b2rwherelastlogg = rev-range-this-branch --any --branch-number 2 --keep-last wherelastlogg
	b2rwherelastloggv = rev-range-this-branch --any --branch-number 2 --keep-last wherelastloggv
	b2rwherelastshowg = rev-range-this-branch --any --branch-number 2 --keep-last wherelastshowg
	b2rwhereintroducedlog = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedlog
	b2rwhereintroducedlogv = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedlogv
	b2rwhereintroducedshow = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedshow
	b2rwhereintroducedlogg = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedlogg
	b2rwhereintroducedloggv = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedloggv
	b2rwhereintroducedshowg = rev-range-this-branch --any --branch-number 2 --keep-last whereintroducedshowg
	b2rlc = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lc
	b2rlcf = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcf --reverse
	b2rlcl = rev-range-this-branch --any --branch-number 2 lcl --reverse
	b2rlclf = rev-range-this-branch --any --branch-number 2 lclf --reverse
	b2rlcmine = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcmine --reverse
	b2rlcteam = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcteam --reverse
	b2rlcby = dashdash-default-command : rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding others-command lc --reverse :
	b2rlcfmine = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcfmine --reverse
	b2rlcfteam = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcfteam --reverse
	b2rlcfby = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding lcfby --reverse
	b2rshow = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding show
	b2rshoww = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding showw
	b2rshowc = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding showc
	b2rshowa = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding showa
	b2rshowfiles = rev-range-this-branch --any --branch-number 2 --with-range ... showfiles
	b2rshowselected = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding showselected
	b2rshowlselected = rev-range-this-branch --any --branch-number 2 --one-more-command log --one-more-with-padding showlselected
	b2rlog = rev-range-this-branch --any --branch-number 2 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	b2rlogv = rev-range-this-branch --any --branch-number 2 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	b2rglog = rev-range-this-branch --any --branch-number 2 glog
	b2rlogg = rev-range-this-branch --any --branch-number 2 --keep-last logg
	b2rlgg = rev-range-this-branch --any --branch-number 2 --keep-last lgg
	b2rl = rev-range-this-branch --any --branch-number 2 l
	b2rlmine = rev-range-this-branch --any --branch-number 2 lmine
	b2rlteam = rev-range-this-branch --any --branch-number 2 lteam
	b2rlby = dashdash-default-command : rev-range-this-branch --any --branch-number 2 others-command l :
	b2rlg = rev-range-this-branch --any --branch-number 2 --one-more-command greyonelinelog --one-more-only-to-terminal lg
	b2rlgn = rev-range-this-branch --any --branch-number 2 lg
	b2rlgv = rev-range-this-branch --any --branch-number 2 --one-more lgv
	b2rlh = rev-range-this-branch --any --branch-number 2 lh --reverse
	b2rlhmine = rev-range-this-branch --any --branch-number 2 lhmine --reverse
	b2rlhteam = rev-range-this-branch --any --branch-number 2 lhteam --reverse
	b2rlhby = dashdash-default-command : rev-range-this-branch --any --branch-number 2 others-command lh --reverse :
	b2rlurl = rev-range-this-branch --any --branch-number 2 lurl
	b2rlourl = rev-range-this-branch --any --branch-number 2 lourl --reverse
	b2rluurl = rev-range-this-branch --any --branch-number 2 luurl --reverse
	b2rlourlv = rev-range-this-branch --any --branch-number 2 lourlv --reverse
	b2rluurlv = rev-range-this-branch --any --branch-number 2 luurlv --reverse
	b2rtreeurl = rev-range-this-branch --any --branch-number 2 treeurl
	b2rtreeourl = rev-range-this-branch --any --branch-number 2 treeourl --reverse
	b2rtreeuurl = rev-range-this-branch --any --branch-number 2 treeuurl --reverse
	b2rtreeourlv = rev-range-this-branch --any --branch-number 2 treeourlv --reverse
	b2rtreeuurlv = rev-range-this-branch --any --branch-number 2 treeuurlv --reverse
	b2rlgmine = rev-range-this-branch --any --branch-number 2 --one-more lgmine
	b2rlgteam = rev-range-this-branch --any --branch-number 2 --one-more lgteam
	b2rlgby = dashdash-default-command : rev-range-this-branch --any --branch-number 2 --one-more others-command lg :
	b2rlogmine = rev-range-this-branch --any --branch-number 2 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	b2rlogteam = rev-range-this-branch --any --branch-number 2 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	b2rlogby = dashdash-default-command : rev-range-this-branch --any --branch-number 2 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	b2rrevert = rev-range-this-branch --any --branch-number 2 revertselected
	b2rrevertcommit = rev-range-this-branch --any --branch-number 2 revertcommitselected
	b2rcorrect = rev-range-this-branch --any --branch-number 2 correctselected
	b2rcorrectst = rev-range-this-branch --any --branch-number 2 correctst
	b2rcorrecti = rev-range-this-branch --any --branch-number 2 correcti
	b2rcorrect-i = rev-range-this-branch --any --branch-number 2 correct-i
	b2rfixup = rev-range-this-branch --any --branch-number 2 fixupselected
	b2rfixupst = rev-range-this-branch --any --branch-number 2 fixupst
	b2rfixupi = rev-range-this-branch --any --branch-number 2 fixupi
	b2rfixup-i = rev-range-this-branch --any --branch-number 2 fixup-i
	b2rrbfixup = rev-range-this-branch --any --branch-number 2 rbfixupselected
	b2rcommitidentical = rev-range-this-branch --any --branch-number 2 commitidenticalselected
	b2rcommitidenticalst = rev-range-this-branch --any --branch-number 2 commitidenticalst
	b2rcommitidenticali = rev-range-this-branch --any --branch-number 2 commitidenticali
	b2rcommitidentical-i = rev-range-this-branch --any --branch-number 2 commitidentical-i
	b2rcommitlike = rev-range-this-branch --any --branch-number 2 commitlikeselected
	b2rcommitlikest = rev-range-this-branch --any --branch-number 2 commitlikest
	b2rcommitlikei = rev-range-this-branch --any --branch-number 2 commitlikei
	b2rcommitlike-i = rev-range-this-branch --any --branch-number 2 commitlike-i
	b2rrbi = rev-range-this-branch --any --branch-number 2 --no-range rebase -i
	b2rrbni = rev-range-this-branch --any --branch-number 2 --no-range rbni
	b2rwipe = rev-range-this-branch --any --branch-number 2 wipetoselected
	b2rbase = rev-range-this-branch --any --branch-number 2 --no-range name-rev --name-only
	b2rwhodid = files-command whodid b2rshowfiles
	b2rwhotouched = rev-range-this-branch --any --branch-number 2 whodid
	b2rwhatdid = rev-range-this-branch --any --branch-number 2 whatdid
	b2ractivity = rev-range-this-branch --any --branch-number 2 activity
	b2ractivitymine = rev-range-this-branch --any --branch-number 2 activitymine
	b2ractivityteam = rev-range-this-branch --any --branch-number 2 activityteam
	b2rlogdistribution = rev-range-this-branch --any --branch-number 2 logdistribution
	b2rlogdistributionmine = rev-range-this-branch --any --branch-number 2 logdistributionmine
	b2rlogdistributionteam = rev-range-this-branch --any --branch-number 2 logdistributionteam
	b2remaillog = rev-range-this-branch --any --branch-number 2 email-command log
	b2remaillc = rev-range-this-branch --any --branch-number 2 email-command lc
	b2rreintegrate = previousbranch-command --branch-number 2 --keep-position reintegrateto --branch BRANCH
	b2rpull-request = previousbranch-command --branch-number 2 --keep-position pull-request --base BRANCH

	;; b3r...: Log variants that only cover the current / passed via -b|--branch and two preceding branches (as tagged or referenced anywhere in the history (also by remotes))
	b3rchurn = rev-range-this-branch --any --branch-number 3 churn
	b3rd = rev-range-this-branch --any --branch-number 3 --with-range ... diff
	b3rdl = rev-range-this-branch --any --branch-number 3 --with-range ... dl
	b3rdt = rev-range-this-branch --any --branch-number 3 --with-range ... difftool
	b3rma = rev-range-this-branch --any --branch-number 3 format-patch
	b3rfindlog = rev-range-this-branch --any --branch-number 3 --keep-last findlog
	b3rfindlogv = rev-range-this-branch --any --branch-number 3 --keep-last findlogv
	b3rfindlg = rev-range-this-branch --any --branch-number 3 --keep-last findlg
	b3rfindlc = rev-range-this-branch --any --branch-number 3 --keep-last findlc
	b3rfindlcl = rev-range-this-branch --any --branch-number 3 --keep-last findlcl
	b3rfindshow = rev-range-this-branch --any --branch-number 3 --keep-last findshow
	b3rfindlogg = rev-range-this-branch --any --branch-number 3 --keep-last findlogg
	b3rfindloggv = rev-range-this-branch --any --branch-number 3 --keep-last findloggv
	b3rfindlgg = rev-range-this-branch --any --branch-number 3 --keep-last findlgg
	b3rfindlcg = rev-range-this-branch --any --branch-number 3 --keep-last findlcg
	b3rfindlclg = rev-range-this-branch --any --branch-number 3 --keep-last findlclg
	b3rtouchedlog = rev-range-this-branch --any --branch-number 3 --keep-last touchedlog
	b3rtouchedlogv = rev-range-this-branch --any --branch-number 3 --keep-last touchedlogv
	b3rtouchedlg = rev-range-this-branch --any --branch-number 3 --keep-last touchedlg
	b3rtouchedlc = rev-range-this-branch --any --branch-number 3 --keep-last touchedlc
	b3rtouchedlcl = rev-range-this-branch --any --branch-number 3 --keep-last touchedlcl
	b3rtouchedshow = rev-range-this-branch --any --branch-number 3 --keep-last touchedshow
	b3rtouchedlogg = rev-range-this-branch --any --branch-number 3 --keep-last touchedlogg
	b3rtouchedloggv = rev-range-this-branch --any --branch-number 3 --keep-last touchedloggv
	b3rtouchedlgg = rev-range-this-branch --any --branch-number 3 --keep-last touchedlgg
	b3rtouchedlcg = rev-range-this-branch --any --branch-number 3 --keep-last touchedlcg
	b3rtouchedlclg = rev-range-this-branch --any --branch-number 3 --keep-last touchedlclg
	b3rwherelastlog = rev-range-this-branch --any --branch-number 3 --keep-last wherelastlog
	b3rwherelastlogv = rev-range-this-branch --any --branch-number 3 --keep-last wherelastlogv
	b3rwherelastshow = rev-range-this-branch --any --branch-number 3 --keep-last wherelastshow
	b3rwherelastlogg = rev-range-this-branch --any --branch-number 3 --keep-last wherelastlogg
	b3rwherelastloggv = rev-range-this-branch --any --branch-number 3 --keep-last wherelastloggv
	b3rwherelastshowg = rev-range-this-branch --any --branch-number 3 --keep-last wherelastshowg
	b3rwhereintroducedlog = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedlog
	b3rwhereintroducedlogv = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedlogv
	b3rwhereintroducedshow = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedshow
	b3rwhereintroducedlogg = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedlogg
	b3rwhereintroducedloggv = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedloggv
	b3rwhereintroducedshowg = rev-range-this-branch --any --branch-number 3 --keep-last whereintroducedshowg
	b3rlc = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lc
	b3rlcf = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcf --reverse
	b3rlcl = rev-range-this-branch --any --branch-number 3 lcl --reverse
	b3rlclf = rev-range-this-branch --any --branch-number 3 lclf --reverse
	b3rlcmine = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcmine --reverse
	b3rlcteam = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcteam --reverse
	b3rlcby = dashdash-default-command : rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding others-command lc --reverse :
	b3rlcfmine = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcfmine --reverse
	b3rlcfteam = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcfteam --reverse
	b3rlcfby = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding lcfby --reverse
	b3rshow = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding show
	b3rshoww = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding showw
	b3rshowc = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding showc
	b3rshowa = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding showa
	b3rshowfiles = rev-range-this-branch --any --branch-number 3 --with-range ... showfiles
	b3rshowselected = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding showselected
	b3rshowlselected = rev-range-this-branch --any --branch-number 3 --one-more-command log --one-more-with-padding showlselected
	b3rlog = rev-range-this-branch --any --branch-number 3 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	b3rlogv = rev-range-this-branch --any --branch-number 3 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	b3rglog = rev-range-this-branch --any --branch-number 3 glog
	b3rlogg = rev-range-this-branch --any --branch-number 3 --keep-last logg
	b3rlgg = rev-range-this-branch --any --branch-number 3 --keep-last lgg
	b3rl = rev-range-this-branch --any --branch-number 3 l
	b3rlmine = rev-range-this-branch --any --branch-number 3 lmine
	b3rlteam = rev-range-this-branch --any --branch-number 3 lteam
	b3rlby = dashdash-default-command : rev-range-this-branch --any --branch-number 3 others-command l :
	b3rlg = rev-range-this-branch --any --branch-number 3 --one-more-command greyonelinelog --one-more-only-to-terminal lg
	b3rlgn = rev-range-this-branch --any --branch-number 3 lg
	b3rlgv = rev-range-this-branch --any --branch-number 3 --one-more lgv
	b3rlh = rev-range-this-branch --any --branch-number 3 lh --reverse
	b3rlhmine = rev-range-this-branch --any --branch-number 3 lhmine --reverse
	b3rlhteam = rev-range-this-branch --any --branch-number 3 lhteam --reverse
	b3rlhby = dashdash-default-command : rev-range-this-branch --any --branch-number 3 others-command lh --reverse :
	b3rlurl = rev-range-this-branch --any --branch-number 3 lurl
	b3rlourl = rev-range-this-branch --any --branch-number 3 lourl --reverse
	b3rluurl = rev-range-this-branch --any --branch-number 3 luurl --reverse
	b3rlourlv = rev-range-this-branch --any --branch-number 3 lourlv --reverse
	b3rluurlv = rev-range-this-branch --any --branch-number 3 luurlv --reverse
	b3rtreeurl = rev-range-this-branch --any --branch-number 3 treeurl
	b3rtreeourl = rev-range-this-branch --any --branch-number 3 treeourl --reverse
	b3rtreeuurl = rev-range-this-branch --any --branch-number 3 treeuurl --reverse
	b3rtreeourlv = rev-range-this-branch --any --branch-number 3 treeourlv --reverse
	b3rtreeuurlv = rev-range-this-branch --any --branch-number 3 treeuurlv --reverse
	b3rlgmine = rev-range-this-branch --any --branch-number 3 --one-more lgmine
	b3rlgteam = rev-range-this-branch --any --branch-number 3 --one-more lgteam
	b3rlgby = dashdash-default-command : rev-range-this-branch --any --branch-number 3 --one-more others-command lg :
	b3rlogmine = rev-range-this-branch --any --branch-number 3 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	b3rlogteam = rev-range-this-branch --any --branch-number 3 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	b3rlogby = dashdash-default-command : rev-range-this-branch --any --branch-number 3 --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	b3rrevert = rev-range-this-branch --any --branch-number 3 revertselected
	b3rrevertcommit = rev-range-this-branch --any --branch-number 3 revertcommitselected
	b3rcorrect = rev-range-this-branch --any --branch-number 3 correctselected
	b3rcorrectst = rev-range-this-branch --any --branch-number 3 correctst
	b3rcorrecti = rev-range-this-branch --any --branch-number 3 correcti
	b3rcorrect-i = rev-range-this-branch --any --branch-number 3 correct-i
	b3rfixup = rev-range-this-branch --any --branch-number 3 fixupselected
	b3rfixupst = rev-range-this-branch --any --branch-number 3 fixupst
	b3rfixupi = rev-range-this-branch --any --branch-number 3 fixupi
	b3rfixup-i = rev-range-this-branch --any --branch-number 3 fixup-i
	b3rrbfixup = rev-range-this-branch --any --branch-number 3 rbfixupselected
	b3rcommitidentical = rev-range-this-branch --any --branch-number 3 commitidenticalselected
	b3rcommitidenticalst = rev-range-this-branch --any --branch-number 3 commitidenticalst
	b3rcommitidenticali = rev-range-this-branch --any --branch-number 3 commitidenticali
	b3rcommitidentical-i = rev-range-this-branch --any --branch-number 3 commitidentical-i
	b3rcommitlike = rev-range-this-branch --any --branch-number 3 commitlikeselected
	b3rcommitlikest = rev-range-this-branch --any --branch-number 3 commitlikest
	b3rcommitlikei = rev-range-this-branch --any --branch-number 3 commitlikei
	b3rcommitlike-i = rev-range-this-branch --any --branch-number 3 commitlike-i
	b3rrbi = rev-range-this-branch --any --branch-number 3 --no-range rebase -i
	b3rrbni = rev-range-this-branch --any --branch-number 3 --no-range rbni
	b3rwipe = rev-range-this-branch --any --branch-number 3 wipetoselected
	b3rbase = rev-range-this-branch --any --branch-number 3 --no-range name-rev --name-only
	b3rwhodid = files-command whodid b3rshowfiles
	b3rwhotouched = rev-range-this-branch --any --branch-number 3 whodid
	b3rwhatdid = rev-range-this-branch --any --branch-number 3 whatdid
	b3ractivity = rev-range-this-branch --any --branch-number 3 activity
	b3ractivitymine = rev-range-this-branch --any --branch-number 3 activitymine
	b3ractivityteam = rev-range-this-branch --any --branch-number 3 activityteam
	b3rlogdistribution = rev-range-this-branch --any --branch-number 3 logdistribution
	b3rlogdistributionmine = rev-range-this-branch --any --branch-number 3 logdistributionmine
	b3rlogdistributionteam = rev-range-this-branch --any --branch-number 3 logdistributionteam
	b3remaillog = rev-range-this-branch --any --branch-number 3 email-command log
	b3remaillc = rev-range-this-branch --any --branch-number 3 email-command lc
	b3rreintegrate = previousbranch-command --branch-number 3 --keep-position reintegrateto --branch BRANCH
	b3rpull-request = previousbranch-command --branch-number 3 --keep-position pull-request --base BRANCH

	;; bm...: Log variants that cover the differences of the current / passed via -b|--branch branch to master.
	bmchurn = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD churn
	bmd = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --with-range ... diff
	bmdl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --with-range ... dl
	bmdt = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --with-range ... difftool
	bmma = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD format-patch
	bmfindlog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlog
	bmfindlogv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlogv
	bmfindlg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlg
	bmfindlc = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlc
	bmfindlcl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlcl
	bmfindshow = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findshow
	bmfindlogg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlogg
	bmfindloggv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findloggv
	bmfindlgg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlgg
	bmfindlcg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlcg
	bmfindlclg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last findlclg
	bmtouchedlog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlog
	bmtouchedlogv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlogv
	bmtouchedlg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlg
	bmtouchedlc = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlc
	bmtouchedlcl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlcl
	bmtouchedshow = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedshow
	bmtouchedlogg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlogg
	bmtouchedloggv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedloggv
	bmtouchedlgg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlgg
	bmtouchedlcg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlcg
	bmtouchedlclg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last touchedlclg
	bmwherelastlog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastlog
	bmwherelastlogv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastlogv
	bmwherelastshow = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastshow
	bmwherelastlogg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastlogg
	bmwherelastloggv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastloggv
	bmwherelastshowg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last wherelastshowg
	bmwhereintroducedlog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedlog
	bmwhereintroducedlogv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedlogv
	bmwhereintroducedshow = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedshow
	bmwhereintroducedlogg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedlogg
	bmwhereintroducedloggv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedloggv
	bmwhereintroducedshowg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last whereintroducedshowg
	bmlc = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lc
	bmlcf = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	bmlcl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lcl --reverse
	bmlclf = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lclf --reverse
	bmlcmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	bmlcteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	bmlcby = dashdash-default-command : branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	bmlcfmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	bmlcfteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	bmlcfby = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	bmshow = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding show
	bmshoww = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding showw
	bmshowc = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding showc
	bmshowa = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding showa
	bmshowfiles = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --with-range ... showfiles
	bmshowselected = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	bmshowlselected = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	bmlog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	bmlogv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	bmglog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD glog
	bmlogg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last logg
	bmlgg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --keep-last lgg
	bml = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD l
	bmlmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lmine
	bmlteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lteam
	bmlby = dashdash-default-command : branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD others-command l :
	bmlg = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	bmlgn = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lg
	bmlgv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more lgv
	bmlh = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lh --reverse
	bmlhmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lhmine --reverse
	bmlhteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lhteam --reverse
	bmlhby = dashdash-default-command : branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD others-command lh --reverse :
	bmlurl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lurl
	bmlourl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lourl --reverse
	bmluurl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD luurl --reverse
	bmlourlv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD lourlv --reverse
	bmluurlv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD luurlv --reverse
	bmtreeurl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD treeurl
	bmtreeourl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD treeourl --reverse
	bmtreeuurl = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD treeuurl --reverse
	bmtreeourlv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD treeourlv --reverse
	bmtreeuurlv = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD treeuurlv --reverse
	bmlgmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more lgmine
	bmlgteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more lgteam
	bmlgby = dashdash-default-command : branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more others-command lg :
	bmlogmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	bmlogteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	bmlogby = dashdash-default-command : branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	bmrevert = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD revertselected
	bmrevertcommit = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD revertcommitselected
	bmcorrect = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD correctselected
	bmcorrectst = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD correctst
	bmcorrecti = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD correcti
	bmcorrect-i = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD correct-i
	bmfixup = master-command --keep-position rev-range --revision MASTER --end-revision HEAD fixupselected
	bmfixupst = master-command --keep-position rev-range --revision MASTER --end-revision HEAD fixupst
	bmfixupi = master-command --keep-position rev-range --revision MASTER --end-revision HEAD fixupi
	bmfixup-i = master-command --keep-position rev-range --revision MASTER --end-revision HEAD fixup-i
	bmrbfixup = master-command --keep-position rev-range --revision MASTER --end-revision HEAD rbfixupselected
	bmcommitidentical = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitidenticalselected
	bmcommitidenticalst = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitidenticalst
	bmcommitidenticali = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitidenticali
	bmcommitidentical-i = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitidentical-i
	bmcommitlike = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitlikeselected
	bmcommitlikest = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitlikest
	bmcommitlikei = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitlikei
	bmcommitlike-i = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD commitlike-i
	bmrbi = master-command --keep-position rev-range --revision MASTER --no-range rebase -i
	bmrbni = master-command --keep-position rev-range --revision MASTER --no-range rbni
	bmwipe = branch-command --keep-position master-command --keep-position rev-range --revision MASTER wipetoselected
	bmbase = master-command --keep-position rev-range --revision MASTER --no-range name-rev --name-only
	bmwhodid = files-command whodid bmshowfiles
	bmwhotouched = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD whodid
	bmwhatdid = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD whatdid
	bmactivity = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD activity
	bmactivitymine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD activitymine
	bmactivityteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD activityteam
	bmlogdistribution = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD logdistribution
	bmlogdistributionmine = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD logdistributionmine
	bmlogdistributionteam = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD logdistributionteam
	bmemaillog = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD email-command log
	bmemaillc = branch-command --keep-position master-command --keep-position rev-range --revision MASTER --end-revision HEAD email-command lc
	bmreintegrate = master-command --keep-position reintegrateto --branch MASTER
	bmpull-request = master-command --keep-position pull-request --base MASTER

	;; bn...: Log variants that cover the differences of the current / passed via -b|--branch branch to the base branch.
	bnchurn = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD churn
	bnd = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --with-range ... diff
	bndl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --with-range ... dl
	bndt = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --with-range ... difftool
	bnma = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD format-patch
	bnfindlog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlog
	bnfindlogv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlogv
	bnfindlg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlg
	bnfindlc = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlc
	bnfindlcl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlcl
	bnfindshow = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findshow
	bnfindlogg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlogg
	bnfindloggv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findloggv
	bnfindlgg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlgg
	bnfindlcg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlcg
	bnfindlclg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last findlclg
	bntouchedlog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlog
	bntouchedlogv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlogv
	bntouchedlg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlg
	bntouchedlc = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlc
	bntouchedlcl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlcl
	bntouchedshow = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedshow
	bntouchedlogg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlogg
	bntouchedloggv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedloggv
	bntouchedlgg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlgg
	bntouchedlcg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlcg
	bntouchedlclg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last touchedlclg
	bnwherelastlog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastlog
	bnwherelastlogv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastlogv
	bnwherelastshow = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastshow
	bnwherelastlogg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastlogg
	bnwherelastloggv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastloggv
	bnwherelastshowg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last wherelastshowg
	bnwhereintroducedlog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedlog
	bnwhereintroducedlogv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedlogv
	bnwhereintroducedshow = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedshow
	bnwhereintroducedlogg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedlogg
	bnwhereintroducedloggv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedloggv
	bnwhereintroducedshowg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last whereintroducedshowg
	bnlc = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lc
	bnlcf = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	bnlcl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lcl --reverse
	bnlclf = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lclf --reverse
	bnlcmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	bnlcteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	bnlcby = dashdash-default-command : branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	bnlcfmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	bnlcfteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	bnlcfby = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	bnshow = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding show
	bnshoww = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding showw
	bnshowc = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding showc
	bnshowa = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding showa
	bnshowfiles = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --with-range ... showfiles
	bnshowselected = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	bnshowlselected = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	bnlog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	bnlogv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	bnglog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD glog
	bnlogg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last logg
	bnlgg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --keep-last lgg
	bnl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD l
	bnlmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lmine
	bnlteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lteam
	bnlby = dashdash-default-command : branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD others-command l :
	bnlg = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	bnlgn = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lg
	bnlgv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more lgv
	bnlh = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lh --reverse
	bnlhmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lhmine --reverse
	bnlhteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lhteam --reverse
	bnlhby = dashdash-default-command : branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD others-command lh --reverse :
	bnlurl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lurl
	bnlourl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lourl --reverse
	bnluurl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD luurl --reverse
	bnlourlv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD lourlv --reverse
	bnluurlv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD luurlv --reverse
	bntreeurl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD treeurl
	bntreeourl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD treeourl --reverse
	bntreeuurl = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD treeuurl --reverse
	bntreeourlv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD treeourlv --reverse
	bntreeuurlv = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD treeuurlv --reverse
	bnlgmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more lgmine
	bnlgteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more lgteam
	bnlgby = dashdash-default-command : branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more others-command lg :
	bnlogmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	bnlogteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	bnlogby = dashdash-default-command : branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	bnrevert = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD revertselected
	bnrevertcommit = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD revertcommitselected
	bncorrect = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD correctselected
	bncorrectst = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD correctst
	bncorrecti = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD correcti
	bncorrect-i = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD correct-i
	bnfixup = base-command --keep-position rev-range --revision BASE --end-revision HEAD fixupselected
	bnfixupst = base-command --keep-position rev-range --revision BASE --end-revision HEAD fixupst
	bnfixupi = base-command --keep-position rev-range --revision BASE --end-revision HEAD fixupi
	bnfixup-i = base-command --keep-position rev-range --revision BASE --end-revision HEAD fixup-i
	bnrbfixup = base-command --keep-position rev-range --revision BASE --end-revision HEAD rbfixupselected
	bncommitidentical = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitidenticalselected
	bncommitidenticalst = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitidenticalst
	bncommitidenticali = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitidenticali
	bncommitidentical-i = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitidentical-i
	bncommitlike = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitlikeselected
	bncommitlikest = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitlikest
	bncommitlikei = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitlikei
	bncommitlike-i = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD commitlike-i
	bnrbi = base-command --keep-position rev-range --revision BASE --no-range rebase -i
	bnrbni = base-command --keep-position rev-range --revision BASE --no-range rbni
	bnwipe = branch-command --keep-position base-command --keep-position rev-range --revision BASE wipetoselected
	bnbase = base-command --keep-position rev-range --revision BASE --no-range name-rev --name-only
	bnwhodid = files-command whodid bnshowfiles
	bnwhotouched = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD whodid
	bnwhatdid = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD whatdid
	bnactivity = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD activity
	bnactivitymine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD activitymine
	bnactivityteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD activityteam
	bnlogdistribution = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD logdistribution
	bnlogdistributionmine = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD logdistributionmine
	bnlogdistributionteam = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD logdistributionteam
	bnemaillog = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD email-command log
	bnemaillc = branch-command --keep-position base-command --keep-position rev-range --revision BASE --end-revision HEAD email-command lc
	bnreintegrate = base-command --keep-position reintegrateto --branch BASE
	bnpull-request = base-command --keep-position pull-request --base BASE

	;; bl...: Log variants that cover the differences of the current / passed via -b|--branch branch to the last checked-out branch (typically the one it was branched off).
	blchurn = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD churn
	bld = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --with-range ... diff
	bldl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --with-range ... dl
	bldt = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --with-range ... difftool
	blma = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD format-patch
	blfindlog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlog
	blfindlogv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlogv
	blfindlg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlg
	blfindlc = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlc
	blfindlcl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlcl
	blfindshow = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findshow
	blfindlogg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlogg
	blfindloggv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findloggv
	blfindlgg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlgg
	blfindlcg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlcg
	blfindlclg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last findlclg
	bltouchedlog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlog
	bltouchedlogv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlogv
	bltouchedlg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlg
	bltouchedlc = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlc
	bltouchedlcl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlcl
	bltouchedshow = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedshow
	bltouchedlogg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlogg
	bltouchedloggv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedloggv
	bltouchedlgg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlgg
	bltouchedlcg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlcg
	bltouchedlclg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last touchedlclg
	blwherelastlog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastlog
	blwherelastlogv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastlogv
	blwherelastshow = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastshow
	blwherelastlogg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastlogg
	blwherelastloggv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastloggv
	blwherelastshowg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last wherelastshowg
	blwhereintroducedlog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedlog
	blwhereintroducedlogv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedlogv
	blwhereintroducedshow = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedshow
	blwhereintroducedlogg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedlogg
	blwhereintroducedloggv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedloggv
	blwhereintroducedshowg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last whereintroducedshowg
	bllc = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lc
	bllcf = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	bllcl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lcl --reverse
	bllclf = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lclf --reverse
	bllcmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	bllcteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	bllcby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	bllcfmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	bllcfteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	bllcfby = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	blshow = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding show
	blshoww = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding showw
	blshowc = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding showc
	blshowa = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding showa
	blshowfiles = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --with-range ... showfiles
	blshowselected = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	blshowlselected = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	bllog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	bllogv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	blglog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD glog
	bllogg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last logg
	bllgg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --keep-last lgg
	bll = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD l
	bllmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lmine
	bllteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lteam
	bllby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD others-command l :
	bllg = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	bllgn = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lg
	bllgv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more lgv
	bllh = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lh --reverse
	bllhmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lhmine --reverse
	bllhteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lhteam --reverse
	bllhby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD others-command lh --reverse :
	bllurl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lurl
	bllourl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lourl --reverse
	blluurl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD luurl --reverse
	bllourlv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD lourlv --reverse
	blluurlv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD luurlv --reverse
	bltreeurl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD treeurl
	bltreeourl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD treeourl --reverse
	bltreeuurl = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD treeuurl --reverse
	bltreeourlv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD treeourlv --reverse
	bltreeuurlv = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD treeuurlv --reverse
	bllgmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more lgmine
	bllgteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more lgteam
	bllgby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more others-command lg :
	bllogmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	bllogteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	bllogby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	blrevert = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD revertselected
	blrevertcommit = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD revertcommitselected
	blcorrect = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD correctselected
	blcorrectst = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD correctst
	blcorrecti = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD correcti
	blcorrect-i = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD correct-i
	blfixup = rev-range --revision @{-1} --end-revision HEAD fixupselected
	blfixupst = rev-range --revision @{-1} --end-revision HEAD fixupst
	blfixupi = rev-range --revision @{-1} --end-revision HEAD fixupi
	blfixup-i = rev-range --revision @{-1} --end-revision HEAD fixup-i
	blrbfixup = rev-range --revision @{-1} --end-revision HEAD rbfixupselected
	blcommitidentical = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitidenticalselected
	blcommitidenticalst = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitidenticalst
	blcommitidenticali = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitidenticali
	blcommitidentical-i = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitidentical-i
	blcommitlike = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitlikeselected
	blcommitlikest = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitlikest
	blcommitlikei = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitlikei
	blcommitlike-i = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD commitlike-i
	blrbi = rev-range --revision @{-1} --no-range rebase -i
	blrbni = rev-range --revision @{-1} --no-range rbni
	blwipe = branch-command --keep-position rev-range --revision @{-1} wipetoselected
	blbase = rev-range --revision @{-1} --no-range name-rev --name-only
	blwhodid = files-command whodid blshowfiles
	blwhotouched = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD whodid
	blwhatdid = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD whatdid
	blactivity = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD activity
	blactivitymine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD activitymine
	blactivityteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD activityteam
	bllogdistribution = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD logdistribution
	bllogdistributionmine = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD logdistributionmine
	bllogdistributionteam = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD logdistributionteam
	blemaillog = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD email-command log
	blemaillc = branch-command --keep-position rev-range --revision @{-1} --end-revision HEAD email-command lc
	blreintegrate = previousbranch-command --last-checkout --keep-position reintegrateto --branch BRANCH
	blpull-request = previousbranch-command --last-checkout --keep-position pull-request --base BRANCH

	;; b2l...: Log variants that cover the differences of the current / passed via -b|--branch branch to the second-last checked out branch.
	b2lchurn = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD churn
	b2ld = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --with-range ... diff
	b2ldl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --with-range ... dl
	b2ldt = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --with-range ... difftool
	b2lma = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD format-patch
	b2lfindlog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlog
	b2lfindlogv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlogv
	b2lfindlg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlg
	b2lfindlc = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlc
	b2lfindlcl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlcl
	b2lfindshow = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findshow
	b2lfindlogg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlogg
	b2lfindloggv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findloggv
	b2lfindlgg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlgg
	b2lfindlcg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlcg
	b2lfindlclg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last findlclg
	b2ltouchedlog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlog
	b2ltouchedlogv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlogv
	b2ltouchedlg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlg
	b2ltouchedlc = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlc
	b2ltouchedlcl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlcl
	b2ltouchedshow = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedshow
	b2ltouchedlogg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlogg
	b2ltouchedloggv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedloggv
	b2ltouchedlgg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlgg
	b2ltouchedlcg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlcg
	b2ltouchedlclg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last touchedlclg
	b2lwherelastlog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastlog
	b2lwherelastlogv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastlogv
	b2lwherelastshow = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastshow
	b2lwherelastlogg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastlogg
	b2lwherelastloggv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastloggv
	b2lwherelastshowg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last wherelastshowg
	b2lwhereintroducedlog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedlog
	b2lwhereintroducedlogv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedlogv
	b2lwhereintroducedshow = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedshow
	b2lwhereintroducedlogg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedlogg
	b2lwhereintroducedloggv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedloggv
	b2lwhereintroducedshowg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last whereintroducedshowg
	b2llc = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lc
	b2llcf = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	b2llcl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lcl --reverse
	b2llclf = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lclf --reverse
	b2llcmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	b2llcteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	b2llcby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	b2llcfmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	b2llcfteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	b2llcfby = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	b2lshow = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding show
	b2lshoww = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding showw
	b2lshowc = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding showc
	b2lshowa = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding showa
	b2lshowfiles = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --with-range ... showfiles
	b2lshowselected = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	b2lshowlselected = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	b2llog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	b2llogv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	b2lglog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD glog
	b2llogg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last logg
	b2llgg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --keep-last lgg
	b2ll = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD l
	b2llmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lmine
	b2llteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lteam
	b2llby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD others-command l :
	b2llg = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	b2llgn = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lg
	b2llgv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more lgv
	b2llh = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lh --reverse
	b2llhmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lhmine --reverse
	b2llhteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lhteam --reverse
	b2llhby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD others-command lh --reverse :
	b2llurl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lurl
	b2llourl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lourl --reverse
	b2lluurl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD luurl --reverse
	b2llourlv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD lourlv --reverse
	b2lluurlv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD luurlv --reverse
	b2ltreeurl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD treeurl
	b2ltreeourl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD treeourl --reverse
	b2ltreeuurl = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD treeuurl --reverse
	b2ltreeourlv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD treeourlv --reverse
	b2ltreeuurlv = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD treeuurlv --reverse
	b2llgmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more lgmine
	b2llgteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more lgteam
	b2llgby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more others-command lg :
	b2llogmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	b2llogteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	b2llogby = dashdash-default-command : branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	b2lrevert = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD revertselected
	b2lrevertcommit = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD revertcommitselected
	b2lcorrect = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD correctselected
	b2lcorrectst = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD correctst
	b2lcorrecti = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD correcti
	b2lcorrect-i = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD correct-i
	b2lfixup = rev-range --revision @{-2} --end-revision HEAD fixupselected
	b2lfixupst = rev-range --revision @{-2} --end-revision HEAD fixupst
	b2lfixupi = rev-range --revision @{-2} --end-revision HEAD fixupi
	b2lfixup-i = rev-range --revision @{-2} --end-revision HEAD fixup-i
	b2lrbfixup = rev-range --revision @{-2} --end-revision HEAD rbfixupselected
	b2lcommitidentical = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitidenticalselected
	b2lcommitidenticalst = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitidenticalst
	b2lcommitidenticali = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitidenticali
	b2lcommitidentical-i = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitidentical-i
	b2lcommitlike = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitlikeselected
	b2lcommitlikest = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitlikest
	b2lcommitlikei = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitlikei
	b2lcommitlike-i = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD commitlike-i
	b2lrbi = rev-range --revision @{-2} --no-range rebase -i
	b2lrbni = rev-range --revision @{-2} --no-range rbni
	b2lwipe = branch-command --keep-position rev-range --revision @{-2} wipetoselected
	b2lbase = rev-range --revision @{-2} --no-range name-rev --name-only
	b2lwhodid = files-command whodid b2lshowfiles
	b2lwhotouched = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD whodid
	b2lwhatdid = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD whatdid
	b2lactivity = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD activity
	b2lactivitymine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD activitymine
	b2lactivityteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD activityteam
	b2logdistribution = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD logdistribution
	b2logdistributionmine = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD logdistributionmine
	b2logdistributionteam = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD logdistributionteam
	b2lemaillog = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD email-command log
	b2lemaillc = branch-command --keep-position rev-range --revision @{-2} --end-revision HEAD email-command lc
	b2lreintegrate = previousbranch-command --last-checkout --branch-number 2 --keep-position reintegrateto --branch BRANCH
	b2lpull-request = previousbranch-command --last-checkout --branch-number 2 --keep-position pull-request --base BRANCH

	;; bp...: Log variants that cover the differences of the current / passed via -b|--branch branch to where the tip of the branch was previously. Useful to see the changes that were just pulled.
	bpchurn = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD churn
	bpd = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --with-range ... diff
	bpdl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --with-range ... dl
	bpdt = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --with-range ... difftool
	bpma = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD format-patch
	bpfindlog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlog
	bpfindlogv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlogv
	bpfindlg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlg
	bpfindlc = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlc
	bpfindlcl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlcl
	bpfindshow = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findshow
	bpfindlogg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlogg
	bpfindloggv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findloggv
	bpfindlgg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlgg
	bpfindlcg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlcg
	bpfindlclg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last findlclg
	bptouchedlog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlog
	bptouchedlogv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlogv
	bptouchedlg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlg
	bptouchedlc = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlc
	bptouchedlcl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlcl
	bptouchedshow = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedshow
	bptouchedlogg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlogg
	bptouchedloggv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedloggv
	bptouchedlgg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlgg
	bptouchedlcg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlcg
	bptouchedlclg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last touchedlclg
	bpwherelastlog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastlog
	bpwherelastlogv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastlogv
	bpwherelastshow = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastshow
	bpwherelastlogg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastlogg
	bpwherelastloggv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastloggv
	bpwherelastshowg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last wherelastshowg
	bpwhereintroducedlog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedlog
	bpwhereintroducedlogv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedlogv
	bpwhereintroducedshow = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedshow
	bpwhereintroducedlogg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedlogg
	bpwhereintroducedloggv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedloggv
	bpwhereintroducedshowg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last whereintroducedshowg
	bplc = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lc
	bplcf = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	bplcl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lcl --reverse
	bplclf = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lclf --reverse
	bplcmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	bplcteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	bplcby = dashdash-default-command : branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	bplcfmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	bplcfteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	bplcfby = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	bpshow = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding show
	bpshoww = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding showw
	bpshowc = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding showc
	bpshowa = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding showa
	bpshowfiles = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --with-range ... showfiles
	bpshowselected = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	bpshowlselected = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	bplog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	bplogv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	bpglog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD glog
	bplogg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last logg
	bplgg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --keep-last lgg
	bpl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD l
	bplmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lmine
	bplteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lteam
	bplby = dashdash-default-command : branch-command --keep-position rev-range --revision @{1} --end-revision HEAD others-command l :
	bplg = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	bplgn = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lg
	bplgv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more lgv
	bplh = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lh --reverse
	bplhmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lhmine --reverse
	bplhteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lhteam --reverse
	bplhby = dashdash-default-command : branch-command --keep-position rev-range --revision @{1} --end-revision HEAD others-command lh --reverse :
	bplurl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lurl
	bplourl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lourl --reverse
	bpluurl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD luurl --reverse
	bplourlv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD lourlv --reverse
	bpluurlv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD luurlv --reverse
	bptreeurl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD treeurl
	bptreeourl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD treeourl --reverse
	bptreeuurl = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD treeuurl --reverse
	bptreeourlv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD treeourlv --reverse
	bptreeuurlv = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD treeuurlv --reverse
	bplgmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more lgmine
	bplgteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more lgteam
	bplgby = dashdash-default-command : branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more others-command lg :
	bplogmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	bplogteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	bplogby = dashdash-default-command : branch-command --keep-position rev-range --revision @{1} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	bprevert = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD revertselected
	bprevertcommit = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD revertcommitselected
	bpcorrect = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD correctselected
	bpcorrectst = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD correctst
	bpcorrecti = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD correcti
	bpcorrect-i = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD correct-i
	bpfixup = rev-range --revision @{1} --end-revision HEAD fixupselected
	bpfixupst = rev-range --revision @{1} --end-revision HEAD fixupst
	bpfixupi = rev-range --revision @{1} --end-revision HEAD fixupi
	bpfixup-i = rev-range --revision @{1} --end-revision HEAD fixup-i
	bprbfixup = rev-range --revision @{1} --end-revision HEAD rbfixupselected
	bpcommitidentical = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitidenticalselected
	bpcommitidenticalst = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitidenticalst
	bpcommitidenticali = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitidenticali
	bpcommitidentical-i = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitidentical-i
	bpcommitlike = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitlikeselected
	bpcommitlikest = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitlikest
	bpcommitlikei = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitlikei
	bpcommitlike-i = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD commitlike-i
	bprbi = rev-range --revision @{1} --no-range --one-more-command ^ rebase -i
	bprbni = rev-range --revision @{1} --no-range --one-more-command ^ rbni
	bpwipe = branch-command --keep-position rev-range --revision @{1} wipetoselected
	bpbase = rev-range --revision @{1} --no-range name-rev --name-only
	bpwhodid = files-command whodid bpshowfiles
	bpwhotouched = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD whodid
	bpwhatdid = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD whatdid
	bpactivity = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD activity
	bpactivitymine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD activitymine
	bpactivityteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD activityteam
	bplogdistribution = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD logdistribution
	bplogdistributionmine = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD logdistributionmine
	bplogdistributionteam = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD logdistributionteam
	bpemaillog = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD email-command log
	bpemaillc = branch-command --keep-position rev-range --revision @{1} --end-revision HEAD email-command lc
	bpreintegrate = previousbranch-command --previous --keep-position reintegrateto --branch BRANCH
	bppull-request = previousbranch-command --previous --keep-position pull-request --base BRANCH

	;; b2p...: Log variants that cover the differences of the current / passed via -b|--branch branch to where the tip of the branch was second-last.
	b2pchurn = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD churn
	b2pd = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --with-range ... diff
	b2pdl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --with-range ... dl
	b2pdt = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --with-range ... difftool
	b2pma = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD format-patch
	b2pfindlog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlog
	b2pfindlogv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlogv
	b2pfindlg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlg
	b2pfindlc = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlc
	b2pfindlcl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlcl
	b2pfindshow = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findshow
	b2pfindlogg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlogg
	b2pfindloggv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findloggv
	b2pfindlgg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlgg
	b2pfindlcg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlcg
	b2pfindlclg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last findlclg
	b2ptouchedlog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlog
	b2ptouchedlogv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlogv
	b2ptouchedlg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlg
	b2ptouchedlc = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlc
	b2ptouchedlcl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlcl
	b2ptouchedshow = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedshow
	b2ptouchedlogg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlogg
	b2ptouchedloggv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedloggv
	b2ptouchedlgg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlgg
	b2ptouchedlcg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlcg
	b2ptouchedlclg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last touchedlclg
	b2pwherelastlog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastlog
	b2pwherelastlogv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastlogv
	b2pwherelastshow = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastshow
	b2pwherelastlogg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastlogg
	b2pwherelastloggv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastloggv
	b2pwherelastshowg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last wherelastshowg
	b2pwhereintroducedlog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedlog
	b2pwhereintroducedlogv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedlogv
	b2pwhereintroducedshow = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedshow
	b2pwhereintroducedlogg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedlogg
	b2pwhereintroducedloggv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedloggv
	b2pwhereintroducedshowg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last whereintroducedshowg
	b2plc = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lc
	b2plcf = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcf --reverse
	b2plcl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lcl --reverse
	b2plclf = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lclf --reverse
	b2plcmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcmine --reverse
	b2plcteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcteam --reverse
	b2plcby = dashdash-default-command : branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding others-command lc --reverse :
	b2plcfmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfmine --reverse
	b2plcfteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfteam --reverse
	b2plcfby = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding lcfby --reverse
	b2pshow = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding show
	b2pshoww = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding showw
	b2pshowc = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding showc
	b2pshowa = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding showa
	b2pshowfiles = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --with-range ... showfiles
	b2pshowselected = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding showselected
	b2pshowlselected = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command log --one-more-with-padding showlselected
	b2plog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	b2plogv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	b2pglog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD glog
	b2plogg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last logg
	b2plgg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --keep-last lgg
	b2pl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD l
	b2plmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lmine
	b2plteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lteam
	b2plby = dashdash-default-command : branch-command --keep-position rev-range --revision @{2} --end-revision HEAD others-command l :
	b2plg = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greyonelinelog --one-more-only-to-terminal lg
	b2plgn = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lg
	b2plgv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more lgv
	b2plh = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lh --reverse
	b2plhmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lhmine --reverse
	b2plhteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lhteam --reverse
	b2plhby = dashdash-default-command : branch-command --keep-position rev-range --revision @{2} --end-revision HEAD others-command lh --reverse :
	b2plurl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lurl
	b2plourl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lourl --reverse
	b2pluurl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD luurl --reverse
	b2plourlv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD lourlv --reverse
	b2pluurlv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD luurlv --reverse
	b2ptreeurl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD treeurl
	b2ptreeourl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD treeourl --reverse
	b2ptreeuurl = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD treeuurl --reverse
	b2ptreeourlv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD treeourlv --reverse
	b2ptreeuurlv = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD treeuurlv --reverse
	b2plgmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more lgmine
	b2plgteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more lgteam
	b2plgby = dashdash-default-command : branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more others-command lg :
	b2plogmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	b2plogteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	b2plogby = dashdash-default-command : branch-command --keep-position rev-range --revision @{2} --end-revision HEAD --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	b2prevert = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD revertselected
	b2prevertcommit = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD revertcommitselected
	b2pcorrect = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD correctselected
	b2pcorrectst = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD correctst
	b2pcorrecti = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD correcti
	b2pcorrect-i = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD correct-i
	b2pfixup = rev-range --revision @{2} --end-revision HEAD fixupselected
	b2pfixupst = rev-range --revision @{2} --end-revision HEAD fixupst
	b2pfixupi = rev-range --revision @{2} --end-revision HEAD fixupi
	b2pfixup-i = rev-range --revision @{2} --end-revision HEAD fixup-i
	b2prbfixup = rev-range --revision @{2} --end-revision HEAD rbfixupselected
	b2pcommitidentical = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitidenticalselected
	b2pcommitidenticalst = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitidenticalst
	b2pcommitidenticali = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitidenticali
	b2pcommitidentical-i = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitidentical-i
	b2pcommitlike = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitlikeselected
	b2pcommitlikest = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitlikest
	b2pcommitlikei = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitlikei
	b2pcommitlike-i = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD commitlike-i
	b2prbi = rev-range --revision @{2} --no-range --one-more-command ^ rebase -i
	b2prbni = rev-range --revision @{2} --no-range --one-more-command ^ rbni
	b2pwipe = branch-command --keep-position rev-range --revision @{2} wipetoselected
	b2pbase = rev-range --revision @{2} --no-range name-rev --name-only
	b2pwhodid = files-command whodid b2pshowfiles
	b2pwhotouched = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD whodid
	b2pwhatdid = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD whatdid
	b2pactivity = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD activity
	b2pactivitymine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD activitymine
	b2pactivityteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD activityteam
	b2plogdistribution = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD logdistribution
	b2plogdistributionmine = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD logdistributionmine
	b2plogdistributionteam = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD logdistributionteam
	b2pemaillog = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD email-command log
	b2pemaillc = branch-command --keep-position rev-range --revision @{2} --end-revision HEAD email-command lc
	b2preintegrate = previousbranch-command --previous --branch-number 2 --keep-position reintegrateto --branch BRANCH
	b2ppull-request = previousbranch-command --previous --branch-number 2 --keep-position pull-request --base BRANCH

	;; out...: Log variants that cover the differences that already exist on the current / passed via -b|--branch branch, but not yet in the corresponding remote branch.
	outchurn = rev-range-outgoing '' churn
	outd = rev-range-outgoing '' --with-range ... diff
	outdl = rev-range-outgoing '' --with-range ... dl
	outdt = rev-range-outgoing '' --with-range ... difftool
	outma = rev-range-outgoing '' format-patch
	outfindlog = rev-range-outgoing '' --keep-last findlog
	outfindlogv = rev-range-outgoing '' --keep-last findlogv
	outfindlg = rev-range-outgoing '' --keep-last findlg
	outfindlc = rev-range-outgoing '' --keep-last findlc
	outfindlcl = rev-range-outgoing '' --keep-last findlcl
	outfindshow = rev-range-outgoing '' --keep-last findshow
	outfindlogg = rev-range-outgoing '' --keep-last findlogg
	outfindloggv = rev-range-outgoing '' --keep-last findloggv
	outfindlgg = rev-range-outgoing '' --keep-last findlgg
	outfindlcg = rev-range-outgoing '' --keep-last findlcg
	outfindlclg = rev-range-outgoing '' --keep-last findlclg
	outtouchedlog = rev-range-outgoing '' --keep-last touchedlog
	outtouchedlogv = rev-range-outgoing '' --keep-last touchedlogv
	outtouchedlg = rev-range-outgoing '' --keep-last touchedlg
	outtouchedlc = rev-range-outgoing '' --keep-last touchedlc
	outtouchedlcl = rev-range-outgoing '' --keep-last touchedlcl
	outtouchedshow = rev-range-outgoing '' --keep-last touchedshow
	outtouchedlogg = rev-range-outgoing '' --keep-last touchedlogg
	outtouchedloggv = rev-range-outgoing '' --keep-last touchedloggv
	outtouchedlgg = rev-range-outgoing '' --keep-last touchedlgg
	outtouchedlcg = rev-range-outgoing '' --keep-last touchedlcg
	outtouchedlclg = rev-range-outgoing '' --keep-last touchedlclg
	outwherelastlog = rev-range-outgoing '' --keep-last wherelastlog
	outwherelastlogv = rev-range-outgoing '' --keep-last wherelastlogv
	outwherelastshow = rev-range-outgoing '' --keep-last wherelastshow
	outwherelastlogg = rev-range-outgoing '' --keep-last wherelastlogg
	outwherelastloggv = rev-range-outgoing '' --keep-last wherelastloggv
	outwherelastshowg = rev-range-outgoing '' --keep-last wherelastshowg
	outwhereintroducedlog = rev-range-outgoing '' --keep-last whereintroducedlog
	outwhereintroducedlogv = rev-range-outgoing '' --keep-last whereintroducedlogv
	outwhereintroducedshow = rev-range-outgoing '' --keep-last whereintroducedshow
	outwhereintroducedlogg = rev-range-outgoing '' --keep-last whereintroducedlogg
	outwhereintroducedloggv = rev-range-outgoing '' --keep-last whereintroducedloggv
	outwhereintroducedshowg = rev-range-outgoing '' --keep-last whereintroducedshowg
	outlc = rev-range-outgoing '' --one-more-command log --one-more-with-padding lc
	outlcf = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcf --reverse
	outlcl = rev-range-outgoing '' lcl --reverse
	outlclf = rev-range-outgoing '' lclf --reverse
	outlcmine = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcmine --reverse
	outlcteam = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcteam --reverse
	outlcby = dashdash-default-command : rev-range-outgoing '' --one-more-command log --one-more-with-padding others-command lc --reverse :
	outlcfmine = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcfmine --reverse
	outlcfteam = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcfteam --reverse
	outlcfby = rev-range-outgoing '' --one-more-command log --one-more-with-padding lcfby --reverse
	outshow = rev-range-outgoing '' --one-more-command log --one-more-with-padding show
	outshoww = rev-range-outgoing '' --one-more-command log --one-more-with-padding showw
	outshowc = rev-range-outgoing '' --one-more-command log --one-more-with-padding showc
	outshowa = rev-range-outgoing '' --one-more-command log --one-more-with-padding showa
	outshowfiles = rev-range-outgoing '' --with-range ... showfiles
	outshowselected = rev-range-outgoing '' --one-more-command log --one-more-with-padding showselected
	outshowlselected = rev-range-outgoing '' --one-more-command log --one-more-with-padding showlselected
	outlog = rev-range-outgoing '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	outlogv = rev-range-outgoing '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	outglog = rev-range-outgoing '' glog
	outlogg = rev-range-outgoing '' --keep-last logg
	outlgg = rev-range-outgoing '' --keep-last lgg
	outl = rev-range-outgoing '' l
	outlmine = rev-range-outgoing '' lmine
	outlteam = rev-range-outgoing '' lteam
	outlby = dashdash-default-command : rev-range-outgoing '' others-command l :
	outlg = rev-range-outgoing '' --one-more-command greyonelinelog --one-more-only-to-terminal lg
	outlgn = rev-range-outgoing '' lg
	outlgv = rev-range-outgoing '' --one-more lgv
	outlh = rev-range-outgoing '' lh --reverse
	outlhmine = rev-range-outgoing '' lhmine --reverse
	outlhteam = rev-range-outgoing '' lhteam --reverse
	outlhby = dashdash-default-command : rev-range-outgoing '' others-command lh --reverse :
	outlurl = rev-range-outgoing '' lurl
	outlourl = rev-range-outgoing '' lourl --reverse
	outluurl = rev-range-outgoing '' luurl --reverse
	outlourlv = rev-range-outgoing '' lourlv --reverse
	outluurlv = rev-range-outgoing '' luurlv --reverse
	outtreeurl = rev-range-outgoing '' treeurl
	outtreeourl = rev-range-outgoing '' treeourl --reverse
	outtreeuurl = rev-range-outgoing '' treeuurl --reverse
	outtreeourlv = rev-range-outgoing '' treeourlv --reverse
	outtreeuurlv = rev-range-outgoing '' treeuurlv --reverse
	outlgmine = rev-range-outgoing '' --one-more lgmine
	outlgteam = rev-range-outgoing '' --one-more lgteam
	outlgby = dashdash-default-command : rev-range-outgoing '' --one-more others-command lg :
	outlogmine = rev-range-outgoing '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	outlogteam = rev-range-outgoing '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	outlogby = dashdash-default-command : rev-range-outgoing '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	outrevert = rev-range-outgoing '' revertselected
	outrevertcommit = rev-range-outgoing '' revertcommitselected
	outcorrect = rev-range-outgoing '' correctselected
	outcorrectst = rev-range-outgoing '' correctst
	outcorrecti = rev-range-outgoing '' correcti
	outcorrect-i = rev-range-outgoing '' correct-i
	outfixup = rev-range-outgoing '' fixupselected
	outfixupst = rev-range-outgoing '' fixupst
	outfixupi = rev-range-outgoing '' fixupi
	outfixup-i = rev-range-outgoing '' fixup-i
	outrbfixup = rev-range-outgoing '' rbfixupselected
	outcommitidentical = rev-range-outgoing '' commitidenticalselected
	outcommitidenticalst = rev-range-outgoing '' commitidenticalst
	outcommitidenticali = rev-range-outgoing '' commitidenticali
	outcommitidentical-i = rev-range-outgoing '' commitidentical-i
	outcommitlike = rev-range-outgoing '' commitlikeselected
	outcommitlikest = rev-range-outgoing '' commitlikest
	outcommitlikei = rev-range-outgoing '' commitlikei
	outcommitlike-i = rev-range-outgoing '' commitlike-i
	outrbi = trbi
	outrbni = trbni
	outwipe = rev-range-outgoing '' --one-more wipetoselected
	outbase = tracks
	outwhodid = files-command whodid outshowfiles
	outwhotouched = rev-range-outgoing '' whodid
	outwhatdid = rev-range-outgoing '' whatdid
	outactivity = rev-range-outgoing '' activity
	outactivitymine = rev-range-outgoing '' activitymine
	outactivityteam = rev-range-outgoing '' activityteam
	outlogdistribution = rev-range-outgoing '' logdistribution
	outlogdistributionmine = rev-range-outgoing '' logdistributionmine
	outlogdistributionteam = rev-range-outgoing '' logdistributionteam
	outemaillog = rev-range-outgoing '' email-command log
	outemaillc = rev-range-outgoing '' email-command lc
	; outreintegrate likely does not cover a branch
	; outpull-request likely does not cover a branch

	;; in...: Log variants that cover the differences that already exist in remote on the current / passed via -b|--branch branch, but not yet in the local branch.
	inchurn = rev-range-incoming '' churn
	ind = rev-range-incoming '' --with-range ... diff
	indl = rev-range-incoming '' --with-range ... dl
	indt = rev-range-incoming '' --with-range ... difftool
	inma = rev-range-incoming '' format-patch
	infindlog = rev-range-incoming '' --keep-last findlog
	infindlogv = rev-range-incoming '' --keep-last findlogv
	infindlg = rev-range-incoming '' --keep-last findlg
	infindlc = rev-range-incoming '' --keep-last findlc
	infindlcl = rev-range-incoming '' --keep-last findlcl
	infindshow = rev-range-incoming '' --keep-last findshow
	infindlogg = rev-range-incoming '' --keep-last findlogg
	infindloggv = rev-range-incoming '' --keep-last findloggv
	infindlgg = rev-range-incoming '' --keep-last findlgg
	infindlcg = rev-range-incoming '' --keep-last findlcg
	infindlclg = rev-range-incoming '' --keep-last findlclg
	intouchedlog = rev-range-incoming '' --keep-last touchedlog
	intouchedlogv = rev-range-incoming '' --keep-last touchedlogv
	intouchedlg = rev-range-incoming '' --keep-last touchedlg
	intouchedlc = rev-range-incoming '' --keep-last touchedlc
	intouchedlcl = rev-range-incoming '' --keep-last touchedlcl
	intouchedshow = rev-range-incoming '' --keep-last touchedshow
	intouchedlogg = rev-range-incoming '' --keep-last touchedlogg
	intouchedloggv = rev-range-incoming '' --keep-last touchedloggv
	intouchedlgg = rev-range-incoming '' --keep-last touchedlgg
	intouchedlcg = rev-range-incoming '' --keep-last touchedlcg
	intouchedlclg = rev-range-incoming '' --keep-last touchedlclg
	inwherelastlog = rev-range-incoming '' --keep-last wherelastlog
	inwherelastlogv = rev-range-incoming '' --keep-last wherelastlogv
	inwherelastshow = rev-range-incoming '' --keep-last wherelastshow
	inwherelastlogg = rev-range-incoming '' --keep-last wherelastlogg
	inwherelastloggv = rev-range-incoming '' --keep-last wherelastloggv
	inwherelastshowg = rev-range-incoming '' --keep-last wherelastshowg
	inwhereintroducedlog = rev-range-incoming '' --keep-last whereintroducedlog
	inwhereintroducedlogv = rev-range-incoming '' --keep-last whereintroducedlogv
	inwhereintroducedshow = rev-range-incoming '' --keep-last whereintroducedshow
	inwhereintroducedlogg = rev-range-incoming '' --keep-last whereintroducedlogg
	inwhereintroducedloggv = rev-range-incoming '' --keep-last whereintroducedloggv
	inwhereintroducedshowg = rev-range-incoming '' --keep-last whereintroducedshowg
	inlc = rev-range-incoming '' --one-more-command log --one-more-with-padding lc
	inlcf = rev-range-incoming '' --one-more-command log --one-more-with-padding lcf --reverse
	inlcl = rev-range-incoming '' lcl --reverse
	inlclf = rev-range-incoming '' lclf --reverse
	inlcmine = rev-range-incoming '' --one-more-command log --one-more-with-padding lcmine --reverse
	inlcteam = rev-range-incoming '' --one-more-command log --one-more-with-padding lcteam --reverse
	inlcby = dashdash-default-command : rev-range-incoming '' --one-more-command log --one-more-with-padding others-command lc --reverse :
	inlcfmine = rev-range-incoming '' --one-more-command log --one-more-with-padding lcfmine --reverse
	inlcfteam = rev-range-incoming '' --one-more-command log --one-more-with-padding lcfteam --reverse
	inlcfby = rev-range-incoming '' --one-more-command log --one-more-with-padding lcfby --reverse
	inshow = rev-range-incoming '' --one-more-command log --one-more-with-padding show
	inshoww = rev-range-incoming '' --one-more-command log --one-more-with-padding showw
	inshowc = rev-range-incoming '' --one-more-command log --one-more-with-padding showc
	inshowa = rev-range-incoming '' --one-more-command log --one-more-with-padding showa
	inshowfiles = rev-range-incoming '' --with-range ... showfiles
	inshowselected = rev-range-incoming '' --one-more-command log --one-more-with-padding showselected
	inshowlselected = rev-range-incoming '' --one-more-command log --one-more-with-padding showlselected
	inlog = rev-range-incoming '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	inlogv = rev-range-incoming '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	inglog = rev-range-incoming '' glog
	inlogg = rev-range-incoming '' --keep-last logg
	inlgg = rev-range-incoming '' --keep-last lgg
	inl = rev-range-incoming '' l
	inlmine = rev-range-incoming '' lmine
	inlteam = rev-range-incoming '' lteam
	inlby = dashdash-default-command : rev-range-incoming '' others-command l :
	inlg = rev-range-incoming '' --one-more-command greyonelinelog --one-more-only-to-terminal lg
	inlgn = rev-range-incoming '' lg
	inlgv = rev-range-incoming '' --one-more lgv
	inlh = rev-range-incoming '' lh --reverse
	inlhmine = rev-range-incoming '' lhmine --reverse
	inlhteam = rev-range-incoming '' lhteam --reverse
	inlhby = dashdash-default-command : rev-range-incoming '' others-command lh --reverse :
	inlurl = rev-range-incoming '' lurl
	inlourl = rev-range-incoming '' lourl --reverse
	inluurl = rev-range-incoming '' luurl --reverse
	inlourlv = rev-range-incoming '' lourlv --reverse
	inluurlv = rev-range-incoming '' luurlv --reverse
	intreeurl = rev-range-incoming '' treeurl
	intreeourl = rev-range-incoming '' treeourl --reverse
	intreeuurl = rev-range-incoming '' treeuurl --reverse
	intreeourlv = rev-range-incoming '' treeourlv --reverse
	intreeuurlv = rev-range-incoming '' treeuurlv --reverse
	inlgmine = rev-range-incoming '' --one-more lgmine
	inlgteam = rev-range-incoming '' --one-more lgteam
	inlgby = dashdash-default-command : rev-range-incoming '' --one-more others-command lg :
	inlogmine = rev-range-incoming '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	inlogteam = rev-range-incoming '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	inlogby = dashdash-default-command : rev-range-incoming '' --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	; inrbfixup doesn't make sense; you cannot rebase stuff in a remote branch.
	; inrbi doesn't make sense; you cannot rebase stuff in a remote branch.
	; inrbni doesn't make sense; you cannot rebase stuff in a remote branch.
	inwipe = rev-range-incoming '' --one-more wipetoselected
	inbase = tracks
	inwhodid = files-command whodid inshowfiles
	inwhotouched = rev-range-incoming '' whodid
	inwhatdid = rev-range-incoming '' whatdid
	inactivity = rev-range-incoming '' activity
	inactivitymine = rev-range-incoming '' activitymine
	inactivityteam = rev-range-incoming '' activityteam
	inlogdistribution = rev-range-incoming '' logdistribution
	inlogdistributionmine = rev-range-incoming '' logdistributionmine
	inlogdistributionteam = rev-range-incoming '' logdistributionteam
	inemaillog = rev-range-incoming '' email-command log
	inemaillc = rev-range-incoming '' email-command lc
	; inreintegrate likely does not cover a branch
	; inpull-request likely does not cover a branch

	;; oout...: Log variants that cover the differences that already exist on the current / passed via -b|--branch branch, but not yet in the corresponding origin branch.
	ooutchurn = rev-range-outgoing origin churn
	ooutd = rev-range-outgoing origin --with-range ... diff
	ooutdl = rev-range-outgoing origin --with-range ... dl
	ooutdt = rev-range-outgoing origin --with-range ... difftool
	ooutma = rev-range-outgoing origin format-patch
	ooutfindlog = rev-range-outgoing origin --keep-last findlog
	ooutfindlogv = rev-range-outgoing origin --keep-last findlogv
	ooutfindlg = rev-range-outgoing origin --keep-last findlg
	ooutfindlc = rev-range-outgoing origin --keep-last findlc
	ooutfindlcl = rev-range-outgoing origin --keep-last findlcl
	ooutfindshow = rev-range-outgoing origin --keep-last findshow
	ooutfindlogg = rev-range-outgoing origin --keep-last findlogg
	ooutfindloggv = rev-range-outgoing origin --keep-last findloggv
	ooutfindlgg = rev-range-outgoing origin --keep-last findlgg
	ooutfindlcg = rev-range-outgoing origin --keep-last findlcg
	ooutfindlclg = rev-range-outgoing origin --keep-last findlclg
	oouttouchedlog = rev-range-outgoing origin --keep-last touchedlog
	oouttouchedlogv = rev-range-outgoing origin --keep-last touchedlogv
	oouttouchedlg = rev-range-outgoing origin --keep-last touchedlg
	oouttouchedlc = rev-range-outgoing origin --keep-last touchedlc
	oouttouchedlcl = rev-range-outgoing origin --keep-last touchedlcl
	oouttouchedshow = rev-range-outgoing origin --keep-last touchedshow
	oouttouchedlogg = rev-range-outgoing origin --keep-last touchedlogg
	oouttouchedloggv = rev-range-outgoing origin --keep-last touchedloggv
	oouttouchedlgg = rev-range-outgoing origin --keep-last touchedlgg
	oouttouchedlcg = rev-range-outgoing origin --keep-last touchedlcg
	oouttouchedlclg = rev-range-outgoing origin --keep-last touchedlclg
	ooutwherelastlog = rev-range-outgoing origin --keep-last wherelastlog
	ooutwherelastlogv = rev-range-outgoing origin --keep-last wherelastlogv
	ooutwherelastshow = rev-range-outgoing origin --keep-last wherelastshow
	ooutwherelastlogg = rev-range-outgoing origin --keep-last wherelastlogg
	ooutwherelastloggv = rev-range-outgoing origin --keep-last wherelastloggv
	ooutwherelastshowg = rev-range-outgoing origin --keep-last wherelastshowg
	ooutwhereintroducedlog = rev-range-outgoing origin --keep-last whereintroducedlog
	ooutwhereintroducedlogv = rev-range-outgoing origin --keep-last whereintroducedlogv
	ooutwhereintroducedshow = rev-range-outgoing origin --keep-last whereintroducedshow
	ooutwhereintroducedlogg = rev-range-outgoing origin --keep-last whereintroducedlogg
	ooutwhereintroducedloggv = rev-range-outgoing origin --keep-last whereintroducedloggv
	ooutwhereintroducedshowg = rev-range-outgoing origin --keep-last whereintroducedshowg
	ooutlc = rev-range-outgoing origin --one-more-command log --one-more-with-padding lc
	ooutlcf = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcf --reverse
	ooutlcl = rev-range-outgoing origin lcl --reverse
	ooutlclf = rev-range-outgoing origin lclf --reverse
	ooutlcmine = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcmine --reverse
	ooutlcteam = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcteam --reverse
	ooutlcby = dashdash-default-command : rev-range-outgoing origin --one-more-command log --one-more-with-padding others-command lc --reverse :
	ooutlcfmine = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcfmine --reverse
	ooutlcfteam = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcfteam --reverse
	ooutlcfby = rev-range-outgoing origin --one-more-command log --one-more-with-padding lcfby --reverse
	ooutshow = rev-range-outgoing origin --one-more-command log --one-more-with-padding show
	ooutshoww = rev-range-outgoing origin --one-more-command log --one-more-with-padding showw
	ooutshowc = rev-range-outgoing origin --one-more-command log --one-more-with-padding showc
	ooutshowa = rev-range-outgoing origin --one-more-command log --one-more-with-padding showa
	ooutshowfiles = rev-range-outgoing origin --with-range ... showfiles
	ooutshowselected = rev-range-outgoing origin --one-more-command log --one-more-with-padding showselected
	ooutshowlselected = rev-range-outgoing origin --one-more-command log --one-more-with-padding showlselected
	ooutlog = rev-range-outgoing origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	ooutlogv = rev-range-outgoing origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	ooutglog = rev-range-outgoing origin glog
	ooutlogg = rev-range-outgoing origin --keep-last logg
	ooutlgg = rev-range-outgoing origin --keep-last lgg
	ooutl = rev-range-outgoing origin l
	ooutlmine = rev-range-outgoing origin lmine
	ooutlteam = rev-range-outgoing origin lteam
	ooutlby = dashdash-default-command : rev-range-outgoing origin others-command l :
	ooutlg = rev-range-outgoing origin --one-more-command greyonelinelog --one-more-only-to-terminal lg
	ooutlgn = rev-range-outgoing origin lg
	ooutlgv = rev-range-outgoing origin --one-more lgv
	ooutlh = rev-range-outgoing origin lh --reverse
	ooutlhmine = rev-range-outgoing origin lhmine --reverse
	ooutlhteam = rev-range-outgoing origin lhteam --reverse
	ooutlhby = dashdash-default-command : rev-range-outgoing origin others-command lh --reverse :
	ooutlurl = rev-range-outgoing origin lurl
	ooutlourl = rev-range-outgoing origin lourl --reverse
	ooutluurl = rev-range-outgoing origin luurl --reverse
	ooutlourlv = rev-range-outgoing origin lourlv --reverse
	ooutluurlv = rev-range-outgoing origin luurlv --reverse
	oouttreeurl = rev-range-outgoing origin treeurl
	oouttreeourl = rev-range-outgoing origin treeourl --reverse
	oouttreeuurl = rev-range-outgoing origin treeuurl --reverse
	oouttreeourlv = rev-range-outgoing origin treeourlv --reverse
	oouttreeuurlv = rev-range-outgoing origin treeuurlv --reverse
	ooutlgmine = rev-range-outgoing origin --one-more lgmine
	ooutlgteam = rev-range-outgoing origin --one-more lgteam
	ooutlgby = dashdash-default-command : rev-range-outgoing origin --one-more others-command lg :
	ooutlogmine = rev-range-outgoing origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	ooutlogteam = rev-range-outgoing origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	ooutlogby = dashdash-default-command : rev-range-outgoing origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	ooutrevert = rev-range-outgoing origin revertselected
	ooutrevertcommit = rev-range-outgoing origin revertcommitselected
	ooutcorrect = rev-range-outgoing origin correctselected
	ooutcorrectst = rev-range-outgoing origin correctst
	ooutcorrecti = rev-range-outgoing origin correcti
	ooutcorrect-i = rev-range-outgoing origin correct-i
	ooutfixup = rev-range-outgoing origin fixupselected
	ooutfixupst = rev-range-outgoing origin fixupst
	ooutfixupi = rev-range-outgoing origin fixupi
	ooutfixup-i = rev-range-outgoing origin fixup-i
	ooutrbfixup = rev-range-outgoing origin rbfixupselected
	ooutcommitidentical = rev-range-outgoing origin commitidenticalselected
	ooutcommitidenticalst = rev-range-outgoing origin commitidenticalst
	ooutcommitidenticali = rev-range-outgoing origin commitidenticali
	ooutcommitidentical-i = rev-range-outgoing origin commitidentical-i
	ooutcommitlike = rev-range-outgoing origin commitlikeselected
	ooutcommitlikest = rev-range-outgoing origin commitlikest
	ooutcommitlikei = rev-range-outgoing origin commitlikei
	ooutcommitlike-i = rev-range-outgoing origin commitlike-i
	ooutrbi = orbi
	ooutrbni = orbni
	ooutwipe = rev-range-outgoing origin --one-more wipetoselected
	; ooutbase would always print "origin/<branch>".
	ooutwhodid = files-command whodid ooutshowfiles
	ooutwhotouched = rev-range-outgoing origin whodid
	ooutwhatdid = rev-range-outgoing origin whatdid
	ooutactivity = rev-range-outgoing origin activity
	ooutactivitymine = rev-range-outgoing origin activitymine
	ooutactivityteam = rev-range-outgoing origin activityteam
	ooutlogdistribution = rev-range-outgoing origin logdistribution
	ooutlogdistributionmine = rev-range-outgoing origin logdistributionmine
	ooutlogdistributionteam = rev-range-outgoing origin logdistributionteam
	ooutemaillog = rev-range-outgoing origin email-command log
	ooutemaillc = rev-range-outgoing origin email-command lc
	; ooutreintegrate would address a remote branch if at all
	; ooutpull-request would address a remote branch if at all

	;; oin...: Log variants that cover the differences that already exist in origin on the current / passed via -b|--branch branch, but not yet in the local branch.
	oinchurn = rev-range-incoming origin churn
	oind = rev-range-incoming origin --with-range ... diff
	oindl = rev-range-incoming origin --with-range ... dl
	oindt = rev-range-incoming origin --with-range ... difftool
	oinma = rev-range-incoming origin format-patch
	oinfindlog = rev-range-incoming origin --keep-last findlog
	oinfindlogv = rev-range-incoming origin --keep-last findlogv
	oinfindlg = rev-range-incoming origin --keep-last findlg
	oinfindlc = rev-range-incoming origin --keep-last findlc
	oinfindlcl = rev-range-incoming origin --keep-last findlcl
	oinfindshow = rev-range-incoming origin --keep-last findshow
	oinfindlogg = rev-range-incoming origin --keep-last findlogg
	oinfindloggv = rev-range-incoming origin --keep-last findloggv
	oinfindlgg = rev-range-incoming origin --keep-last findlgg
	oinfindlcg = rev-range-incoming origin --keep-last findlcg
	oinfindlclg = rev-range-incoming origin --keep-last findlclg
	ointouchedlog = rev-range-incoming origin --keep-last touchedlog
	ointouchedlogv = rev-range-incoming origin --keep-last touchedlogv
	ointouchedlg = rev-range-incoming origin --keep-last touchedlg
	ointouchedlc = rev-range-incoming origin --keep-last touchedlc
	ointouchedlcl = rev-range-incoming origin --keep-last touchedlcl
	ointouchedshow = rev-range-incoming origin --keep-last touchedshow
	ointouchedlogg = rev-range-incoming origin --keep-last touchedlogg
	ointouchedloggv = rev-range-incoming origin --keep-last touchedloggv
	ointouchedlgg = rev-range-incoming origin --keep-last touchedlgg
	ointouchedlcg = rev-range-incoming origin --keep-last touchedlcg
	ointouchedlclg = rev-range-incoming origin --keep-last touchedlclg
	oinwherelastlog = rev-range-incoming origin --keep-last wherelastlog
	oinwherelastlogv = rev-range-incoming origin --keep-last wherelastlogv
	oinwherelastshow = rev-range-incoming origin --keep-last wherelastshow
	oinwherelastlogg = rev-range-incoming origin --keep-last wherelastlogg
	oinwherelastloggv = rev-range-incoming origin --keep-last wherelastloggv
	oinwherelastshowg = rev-range-incoming origin --keep-last wherelastshowg
	oinwhereintroducedlog = rev-range-incoming origin --keep-last whereintroducedlog
	oinwhereintroducedlogv = rev-range-incoming origin --keep-last whereintroducedlogv
	oinwhereintroducedshow = rev-range-incoming origin --keep-last whereintroducedshow
	oinwhereintroducedlogg = rev-range-incoming origin --keep-last whereintroducedlogg
	oinwhereintroducedloggv = rev-range-incoming origin --keep-last whereintroducedloggv
	oinwhereintroducedshowg = rev-range-incoming origin --keep-last whereintroducedshowg
	oinlc = rev-range-incoming origin --one-more-command log --one-more-with-padding lc
	oinlcf = rev-range-incoming origin --one-more-command log --one-more-with-padding lcf --reverse
	oinlcl = rev-range-incoming origin lcl --reverse
	oinlclf = rev-range-incoming origin lclf --reverse
	oinlcmine = rev-range-incoming origin --one-more-command log --one-more-with-padding lcmine --reverse
	oinlcteam = rev-range-incoming origin --one-more-command log --one-more-with-padding lcteam --reverse
	oinlcby = dashdash-default-command : rev-range-incoming origin --one-more-command log --one-more-with-padding others-command lc --reverse :
	oinlcfmine = rev-range-incoming origin --one-more-command log --one-more-with-padding lcfmine --reverse
	oinlcfteam = rev-range-incoming origin --one-more-command log --one-more-with-padding lcfteam --reverse
	oinlcfby = rev-range-incoming origin --one-more-command log --one-more-with-padding lcfby --reverse
	oinshow = rev-range-incoming origin --one-more-command log --one-more-with-padding show
	oinshoww = rev-range-incoming origin --one-more-command log --one-more-with-padding showw
	oinshowc = rev-range-incoming origin --one-more-command log --one-more-with-padding showc
	oinshowa = rev-range-incoming origin --one-more-command log --one-more-with-padding showa
	oinshowfiles = rev-range-incoming origin --with-range ... showfiles
	oinshowselected = rev-range-incoming origin --one-more-command log --one-more-with-padding showselected
	oinshowlselected = rev-range-incoming origin --one-more-command log --one-more-with-padding showlselected
	oinlog = rev-range-incoming origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	oinlogv = rev-range-incoming origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	oinglog = rev-range-incoming origin glog
	oinlogg = rev-range-incoming origin --keep-last logg
	oinlgg = rev-range-incoming origin --keep-last lgg
	oinl = rev-range-incoming origin l
	oinlmine = rev-range-incoming origin lmine
	oinlteam = rev-range-incoming origin lteam
	oinlby = dashdash-default-command : rev-range-incoming origin others-command l :
	oinlg = rev-range-incoming origin --one-more-command greyonelinelog --one-more-only-to-terminal lg
	oinlgn = rev-range-incoming origin lg
	oinlgv = rev-range-incoming origin --one-more lgv
	oinlh = rev-range-incoming origin lh --reverse
	oinlhmine = rev-range-incoming origin lhmine --reverse
	oinlhteam = rev-range-incoming origin lhteam --reverse
	oinlhby = dashdash-default-command : rev-range-incoming origin others-command lh --reverse :
	oinlurl = rev-range-incoming origin lurl
	oinlourl = rev-range-incoming origin lourl --reverse
	oinluurl = rev-range-incoming origin luurl --reverse
	oinlourlv = rev-range-incoming origin lourlv --reverse
	oinluurlv = rev-range-incoming origin luurlv --reverse
	ointreeurl = rev-range-incoming origin treeurl
	ointreeourl = rev-range-incoming origin treeourl --reverse
	ointreeuurl = rev-range-incoming origin treeuurl --reverse
	ointreeourlv = rev-range-incoming origin treeourlv --reverse
	ointreeuurlv = rev-range-incoming origin treeuurlv --reverse
	oinlgmine = rev-range-incoming origin --one-more lgmine
	oinlgteam = rev-range-incoming origin --one-more lgteam
	oinlgby = dashdash-default-command : rev-range-incoming origin --one-more others-command lg :
	oinlogmine = rev-range-incoming origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	oinlogteam = rev-range-incoming origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	oinlogby = dashdash-default-command : rev-range-incoming origin --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	; oinrbfixup doesn't make sense; you cannot rebase stuff in a remote branch.
	; oinrbi doesn't make sense; you cannot rebase stuff in a remote branch.
	; oinrbni doesn't make sense; you cannot rebase stuff in a remote branch.
	oinwipe = rev-range-incoming origin --one-more wipetoselected
	; oinbase would always print "origin/<branch>".
	oinwhodid = files-command whodid oinshowfiles
	oinwhotouched = rev-range-incoming origin whodid
	oinwhatdid = rev-range-incoming origin whatdid
	oinactivity = rev-range-incoming origin activity
	oinactivitymine = rev-range-incoming origin activitymine
	oinactivityteam = rev-range-incoming origin activityteam
	oinlogdistribution = rev-range-incoming origin logdistribution
	oinlogdistributionmine = rev-range-incoming origin logdistributionmine
	oinlogdistributionteam = rev-range-incoming origin logdistributionteam
	oinemaillog = rev-range-incoming origin email-command log
	oinemaillc = rev-range-incoming origin email-command lc
	; oinreintegrate would address a remote branch if at all
	; oinpull-request would address a remote branch if at all

	;; uout...: Log variants that cover the differences that already exist on the current / passed via -b|--branch branch, but not yet in the corresponding upstream branch.
	uoutchurn = rev-range-outgoing upstream churn
	uoutd = rev-range-outgoing upstream --with-range ... diff
	uoutdl = rev-range-outgoing upstream --with-range ... dl
	uoutdt = rev-range-outgoing upstream --with-range ... difftool
	uoutma = rev-range-outgoing upstream format-patch
	uoutfindlog = rev-range-outgoing upstream --keep-last findlog
	uoutfindlogv = rev-range-outgoing upstream --keep-last findlogv
	uoutfindlg = rev-range-outgoing upstream --keep-last findlg
	uoutfindlc = rev-range-outgoing upstream --keep-last findlc
	uoutfindlcl = rev-range-outgoing upstream --keep-last findlcl
	uoutfindshow = rev-range-outgoing upstream --keep-last findshow
	uoutfindlogg = rev-range-outgoing upstream --keep-last findlogg
	uoutfindloggv = rev-range-outgoing upstream --keep-last findloggv
	uoutfindlgg = rev-range-outgoing upstream --keep-last findlgg
	uoutfindlcg = rev-range-outgoing upstream --keep-last findlcg
	uoutfindlclg = rev-range-outgoing upstream --keep-last findlclg
	uouttouchedlog = rev-range-outgoing upstream --keep-last touchedlog
	uouttouchedlogv = rev-range-outgoing upstream --keep-last touchedlogv
	uouttouchedlg = rev-range-outgoing upstream --keep-last touchedlg
	uouttouchedlc = rev-range-outgoing upstream --keep-last touchedlc
	uouttouchedlcl = rev-range-outgoing upstream --keep-last touchedlcl
	uouttouchedshow = rev-range-outgoing upstream --keep-last touchedshow
	uouttouchedlogg = rev-range-outgoing upstream --keep-last touchedlogg
	uouttouchedloggv = rev-range-outgoing upstream --keep-last touchedloggv
	uouttouchedlgg = rev-range-outgoing upstream --keep-last touchedlgg
	uouttouchedlcg = rev-range-outgoing upstream --keep-last touchedlcg
	uouttouchedlclg = rev-range-outgoing upstream --keep-last touchedlclg
	uoutwherelastlog = rev-range-outgoing upstream --keep-last wherelastlog
	uoutwherelastlogv = rev-range-outgoing upstream --keep-last wherelastlogv
	uoutwherelastshow = rev-range-outgoing upstream --keep-last wherelastshow
	uoutwherelastlogg = rev-range-outgoing upstream --keep-last wherelastlogg
	uoutwherelastloggv = rev-range-outgoing upstream --keep-last wherelastloggv
	uoutwherelastshowg = rev-range-outgoing upstream --keep-last wherelastshowg
	uoutwhereintroducedlog = rev-range-outgoing upstream --keep-last whereintroducedlog
	uoutwhereintroducedlogv = rev-range-outgoing upstream --keep-last whereintroducedlogv
	uoutwhereintroducedshow = rev-range-outgoing upstream --keep-last whereintroducedshow
	uoutwhereintroducedlogg = rev-range-outgoing upstream --keep-last whereintroducedlogg
	uoutwhereintroducedloggv = rev-range-outgoing upstream --keep-last whereintroducedloggv
	uoutwhereintroducedshowg = rev-range-outgoing upstream --keep-last whereintroducedshowg
	uoutlc = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lc
	uoutlcf = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcf --reverse
	uoutlcl = rev-range-outgoing upstream lcl --reverse
	uoutlclf = rev-range-outgoing upstream lclf --reverse
	uoutlcmine = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcmine --reverse
	uoutlcteam = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcteam --reverse
	uoutlcby = dashdash-default-command : rev-range-outgoing upstream --one-more-command log --one-more-with-padding others-command lc --reverse :
	uoutlcfmine = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcfmine --reverse
	uoutlcfteam = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcfteam --reverse
	uoutlcfby = rev-range-outgoing upstream --one-more-command log --one-more-with-padding lcfby --reverse
	uoutshow = rev-range-outgoing upstream --one-more-command log --one-more-with-padding show
	uoutshoww = rev-range-outgoing upstream --one-more-command log --one-more-with-padding showw
	uoutshowc = rev-range-outgoing upstream --one-more-command log --one-more-with-padding showc
	uoutshowa = rev-range-outgoing upstream --one-more-command log --one-more-with-padding showa
	uoutshowfiles = rev-range-outgoing upstream --with-range ... showfiles
	uoutshowselected = rev-range-outgoing upstream --one-more-command log --one-more-with-padding showselected
	uoutshowlselected = rev-range-outgoing upstream --one-more-command log --one-more-with-padding showlselected
	uoutlog = rev-range-outgoing upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	uoutlogv = rev-range-outgoing upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	uoutglog = rev-range-outgoing upstream glog
	uoutlogg = rev-range-outgoing upstream --keep-last logg
	uoutlgg = rev-range-outgoing upstream --keep-last lgg
	uoutl = rev-range-outgoing upstream l
	uoutlmine = rev-range-outgoing upstream lmine
	uoutlteam = rev-range-outgoing upstream lteam
	uoutlby = dashdash-default-command : rev-range-outgoing upstream others-command l :
	uoutlg = rev-range-outgoing upstream --one-more-command greyonelinelog --one-more-only-to-terminal lg
	uoutlgn = rev-range-outgoing upstream lg
	uoutlgv = rev-range-outgoing upstream --one-more lgv
	uoutlh = rev-range-outgoing upstream lh --reverse
	uoutlhmine = rev-range-outgoing upstream lhmine --reverse
	uoutlhteam = rev-range-outgoing upstream lhteam --reverse
	uoutlhby = dashdash-default-command : rev-range-outgoing upstream others-command lh --reverse :
	uoutlurl = rev-range-outgoing upstream lurl
	uoutlourl = rev-range-outgoing upstream lourl --reverse
	uoutluurl = rev-range-outgoing upstream luurl --reverse
	uoutlourlv = rev-range-outgoing upstream lourlv --reverse
	uoutluurlv = rev-range-outgoing upstream luurlv --reverse
	uouttreeurl = rev-range-outgoing upstream treeurl
	uouttreeourl = rev-range-outgoing upstream treeourl --reverse
	uouttreeuurl = rev-range-outgoing upstream treeuurl --reverse
	uouttreeourlv = rev-range-outgoing upstream treeourlv --reverse
	uouttreeuurlv = rev-range-outgoing upstream treeuurlv --reverse
	uoutlgmine = rev-range-outgoing upstream --one-more lgmine
	uoutlgteam = rev-range-outgoing upstream --one-more lgteam
	uoutlgby = dashdash-default-command : rev-range-outgoing upstream --one-more others-command lg :
	uoutlogmine = rev-range-outgoing upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	uoutlogteam = rev-range-outgoing upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	uoutlogby = dashdash-default-command : rev-range-outgoing upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	uoutrevert = rev-range-outgoing upstream revertselected
	uoutrevertcommit = rev-range-outgoing upstream revertcommitselected
	uoutcorrect = rev-range-outgoing upstream correctselected
	uoutcorrectst = rev-range-outgoing upstream correctst
	uoutcorrecti = rev-range-outgoing upstream correcti
	uoutcorrect-i = rev-range-outgoing upstream correct-i
	uoutfixup = rev-range-outgoing upstream fixupselected
	uoutfixupst = rev-range-outgoing upstream fixupst
	uoutfixupi = rev-range-outgoing upstream fixupi
	uoutfixup-i = rev-range-outgoing upstream fixup-i
	uoutrbfixup = rev-range-outgoing upstream rbfixupselected
	uoutcommitidentical = rev-range-outgoing upstream commitidenticalselected
	uoutcommitidenticalst = rev-range-outgoing upstream commitidenticalst
	uoutcommitidenticali = rev-range-outgoing upstream commitidenticali
	uoutcommitidentical-i = rev-range-outgoing upstream commitidentical-i
	uoutcommitlike = rev-range-outgoing upstream commitlikeselected
	uoutcommitlikest = rev-range-outgoing upstream commitlikest
	uoutcommitlikei = rev-range-outgoing upstream commitlikei
	uoutcommitlike-i = rev-range-outgoing upstream commitlike-i
	uoutrbi = urbi
	uoutrbni = urbni
	uoutwipe = rev-range-outgoing upstream --one-more wipetoselected
	; uoutbase would always print "upstream/<branch>".
	uoutwhodid = files-command whodid uoutshowfiles
	uoutwhotouched = rev-range-outgoing upstream whodid
	uoutwhatdid = rev-range-outgoing upstream whatdid
	uoutactivity = rev-range-outgoing upstream activity
	uoutactivitymine = rev-range-outgoing upstream activitymine
	uoutactivityteam = rev-range-outgoing upstream activityteam
	uoutlogdistribution = rev-range-outgoing upstream logdistribution
	uoutlogdistributionmine = rev-range-outgoing upstream logdistributionmine
	uoutlogdistributionteam = rev-range-outgoing upstream logdistributionteam
	uoutemaillog = rev-range-outgoing upstream email-command log
	uoutemaillc = rev-range-outgoing upstream email-command lc
	; uoutreintegrate would address a remote branch if at all
	; uoutpull-request would address a remote branch if at all

	;; uin...: Log variants that cover the differences that already exist in upstream on the current / passed via -b|--branch branch, but not yet in the local branch.
	uinchurn = rev-range-incoming upstream churn
	uind = rev-range-incoming upstream --with-range ... diff
	uindl = rev-range-incoming upstream --with-range ... dl
	uindt = rev-range-incoming upstream --with-range ... difftool
	uinma = rev-range-incoming upstream format-patch
	uinfindlog = rev-range-incoming upstream --keep-last findlog
	uinfindlogv = rev-range-incoming upstream --keep-last findlogv
	uinfindlg = rev-range-incoming upstream --keep-last findlg
	uinfindlc = rev-range-incoming upstream --keep-last findlc
	uinfindlcl = rev-range-incoming upstream --keep-last findlcl
	uinfindshow = rev-range-incoming upstream --keep-last findshow
	uinfindlogg = rev-range-incoming upstream --keep-last findlogg
	uinfindloggv = rev-range-incoming upstream --keep-last findloggv
	uinfindlgg = rev-range-incoming upstream --keep-last findlgg
	uinfindlcg = rev-range-incoming upstream --keep-last findlcg
	uinfindlclg = rev-range-incoming upstream --keep-last findlclg
	uintouchedlog = rev-range-incoming upstream --keep-last touchedlog
	uintouchedlogv = rev-range-incoming upstream --keep-last touchedlogv
	uintouchedlg = rev-range-incoming upstream --keep-last touchedlg
	uintouchedlc = rev-range-incoming upstream --keep-last touchedlc
	uintouchedlcl = rev-range-incoming upstream --keep-last touchedlcl
	uintouchedshow = rev-range-incoming upstream --keep-last touchedshow
	uintouchedlogg = rev-range-incoming upstream --keep-last touchedlogg
	uintouchedloggv = rev-range-incoming upstream --keep-last touchedloggv
	uintouchedlgg = rev-range-incoming upstream --keep-last touchedlgg
	uintouchedlcg = rev-range-incoming upstream --keep-last touchedlcg
	uintouchedlclg = rev-range-incoming upstream --keep-last touchedlclg
	uinwherelastlog = rev-range-incoming upstream --keep-last wherelastlog
	uinwherelastlogv = rev-range-incoming upstream --keep-last wherelastlogv
	uinwherelastshow = rev-range-incoming upstream --keep-last wherelastshow
	uinwherelastlogg = rev-range-incoming upstream --keep-last wherelastlogg
	uinwherelastloggv = rev-range-incoming upstream --keep-last wherelastloggv
	uinwherelastshowg = rev-range-incoming upstream --keep-last wherelastshowg
	uinwhereintroducedlog = rev-range-incoming upstream --keep-last whereintroducedlog
	uinwhereintroducedlogv = rev-range-incoming upstream --keep-last whereintroducedlogv
	uinwhereintroducedshow = rev-range-incoming upstream --keep-last whereintroducedshow
	uinwhereintroducedlogg = rev-range-incoming upstream --keep-last whereintroducedlogg
	uinwhereintroducedloggv = rev-range-incoming upstream --keep-last whereintroducedloggv
	uinwhereintroducedshowg = rev-range-incoming upstream --keep-last whereintroducedshowg
	uinlc = rev-range-incoming upstream --one-more-command log --one-more-with-padding lc
	uinlcf = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcf --reverse
	uinlcl = rev-range-incoming upstream lcl --reverse
	uinlclf = rev-range-incoming upstream lclf --reverse
	uinlcmine = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcmine --reverse
	uinlcteam = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcteam --reverse
	uinlcby = dashdash-default-command : rev-range-incoming upstream --one-more-command log --one-more-with-padding others-command lc --reverse :
	uinlcfmine = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcfmine --reverse
	uinlcfteam = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcfteam --reverse
	uinlcfby = rev-range-incoming upstream --one-more-command log --one-more-with-padding lcfby --reverse
	uinshow = rev-range-incoming upstream --one-more-command log --one-more-with-padding show
	uinshoww = rev-range-incoming upstream --one-more-command log --one-more-with-padding showw
	uinshowc = rev-range-incoming upstream --one-more-command log --one-more-with-padding showc
	uinshowa = rev-range-incoming upstream --one-more-command log --one-more-with-padding showa
	uinshowfiles = rev-range-incoming upstream --with-range ... showfiles
	uinshowselected = rev-range-incoming upstream --one-more-command log --one-more-with-padding showselected
	uinshowlselected = rev-range-incoming upstream --one-more-command log --one-more-with-padding showlselected
	uinlog = rev-range-incoming upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal log
	uinlogv = rev-range-incoming upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logv
	uinglog = rev-range-incoming upstream glog
	uinlogg = rev-range-incoming upstream --keep-last logg
	uinlgg = rev-range-incoming upstream --keep-last lgg
	uinl = rev-range-incoming upstream l
	uinlmine = rev-range-incoming upstream lmine
	uinlteam = rev-range-incoming upstream lteam
	uinlby = dashdash-default-command : rev-range-incoming upstream others-command l :
	uinlg = rev-range-incoming upstream --one-more-command greyonelinelog --one-more-only-to-terminal lg
	uinlgn = rev-range-incoming upstream lg
	uinlgv = rev-range-incoming upstream --one-more lgv
	uinlh = rev-range-incoming upstream lh --reverse
	uinlhmine = rev-range-incoming upstream lhmine --reverse
	uinlhteam = rev-range-incoming upstream lhteam --reverse
	uinlhby = dashdash-default-command : rev-range-incoming upstream others-command lh --reverse :
	uinlurl = rev-range-incoming upstream lurl
	uinlourl = rev-range-incoming upstream lourl --reverse
	uinluurl = rev-range-incoming upstream luurl --reverse
	uinlourlv = rev-range-incoming upstream lourlv --reverse
	uinluurlv = rev-range-incoming upstream luurlv --reverse
	uintreeurl = rev-range-incoming upstream treeurl
	uintreeourl = rev-range-incoming upstream treeourl --reverse
	uintreeuurl = rev-range-incoming upstream treeuurl --reverse
	uintreeourlv = rev-range-incoming upstream treeourlv --reverse
	uintreeuurlv = rev-range-incoming upstream treeuurlv --reverse
	uinlgmine = rev-range-incoming upstream --one-more lgmine
	uinlgteam = rev-range-incoming upstream --one-more lgteam
	uinlgby = dashdash-default-command : rev-range-incoming upstream --one-more others-command lg :
	uinlogmine = rev-range-incoming upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logmine
	uinlogteam = rev-range-incoming upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal logteam
	uinlogby = dashdash-default-command : rev-range-incoming upstream --one-more-command greylog --one-more-with-padding --one-more-only-to-terminal others-command log :
	; uinrbfixup doesn't make sense; you cannot rebase stuff in a remote branch.
	; uinrbi doesn't make sense; you cannot rebase stuff in a remote branch.
	; uinrbni doesn't make sense; you cannot rebase stuff in a remote branch.
	uinwipe = rev-range-incoming upstream --one-more wipetoselected
	; uinbase would always print "upstream/<branch>".
	uinwhodid = files-command whodid uinshowfiles
	uinwhotouched = rev-range-incoming upstream whodid
	uinwhatdid = rev-range-incoming upstream whatdid
	uinactivity = rev-range-incoming upstream activity
	uinactivitymine = rev-range-incoming upstream activitymine
	uinactivityteam = rev-range-incoming upstream activityteam
	uinlogdistribution = rev-range-incoming upstream logdistribution
	uinlogdistributionmine = rev-range-incoming upstream logdistributionmine
	uinlogdistributionteam = rev-range-incoming upstream logdistributionteam
	uinemaillog = rev-range-incoming upstream email-command log
	uinemaillc = rev-range-incoming upstream email-command lc
	; uinreintegrate would address a remote branch if at all
	; uinpull-request would address a remote branch if at all

	;; localbr...: Log variants that cover all local branches (like br... ending with a tag or reference anywhere in the history (also by remotes))
	localbrchurn = localbrrefdo git rev-range-this-branch --branch {} --any churn
	localbrd = localbrrefdo git rev-range-this-branch --branch {} --any --with-range ... diff
	localbrdl = localbrrefdo git rev-range-this-branch --branch {} --any --with-range ... dl
	localbrdt = localbrrefdo git rev-range-this-branch --branch {} --any --with-range ... difftool
	localbrma = localbrrefdo git rev-range-this-branch --branch {} --any format-patch
	localbrfindlog = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlog
	localbrfindlogv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlogv
	localbrfindlg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlg
	localbrfindlc = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlc
	localbrfindlcl = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlcl
	localbrfindshow = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findshow
	localbrfindlogg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlogg
	localbrfindloggv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findloggv
	localbrfindlgg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlgg
	localbrfindlcg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlcg
	localbrfindlclg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last findlclg
	localbrtouchedlog = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlog
	localbrtouchedlogv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlogv
	localbrtouchedlg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlg
	localbrtouchedlc = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlc
	localbrtouchedlcl = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlcl
	localbrtouchedshow = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedshow
	localbrtouchedlogg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlogg
	localbrtouchedloggv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedloggv
	localbrtouchedlgg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlgg
	localbrtouchedlcg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlcg
	localbrtouchedlclg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last touchedlclg
	localbrwherelastlog = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastlog
	localbrwherelastlogv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastlogv
	localbrwherelastshow = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastshow
	localbrwherelastlogg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastlogg
	localbrwherelastloggv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastloggv
	localbrwherelastshowg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last wherelastshowg
	localbrwhereintroducedlog = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedlog
	localbrwhereintroducedlogv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedlogv
	localbrwhereintroducedshow = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedshow
	localbrwhereintroducedlogg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedlogg
	localbrwhereintroducedloggv = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedloggv
	localbrwhereintroducedshowg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last whereintroducedshowg
	localbrlc = localbrrefdo git rev-range-this-branch --branch {} --any lc --color=always
	localbrlcf = localbrrefdo git rev-range-this-branch --branch {} --any lcf --reverse --color=always
	localbrlcl = localbrrefdo git rev-range-this-branch --branch {} --any lcl --reverse --color=always
	localbrlclf = localbrrefdo git rev-range-this-branch --branch {} --any lclf --reverse --color=always
	localbrlcmine = localbrrefdo git rev-range-this-branch --branch {} --any lcmine --reverse --color=always
	localbrlcteam = localbrrefdo git rev-range-this-branch --branch {} --any lcteam --reverse --color=always
	localbrlcby = localbrrefdo git dashdash-default-command : rev-range-this-branch --branch {} --any others-command lc --reverse --color=always :
	localbrlcfmine = localbrrefdo git rev-range-this-branch --branch {} --any lcfmine --reverse --color=always
	localbrlcfteam = localbrrefdo git rev-range-this-branch --branch {} --any lcfteam --reverse --color=always
	localbrlcfby = localbrrefdo git rev-range-this-branch --branch {} --any lcfby --reverse --color=always
	localbrshow = localbrrefdo git rev-range-this-branch --branch {} --any show --color=always
	localbrshoww = localbrrefdo git rev-range-this-branch --branch {} --any showw --color=always
	localbrshowc = localbrrefdo git rev-range-this-branch --branch {} --any showc --color=always
	localbrshowa = localbrrefdo git rev-range-this-branch --branch {} --any showa --color=always
	localbrshowfiles = localbrrefdo git rev-range-this-branch --branch {} --any --with-range ... showfiles --color=always
	localbrshowselected = localbrrefdo git rev-range-this-branch --branch {} --any show --color=alwaysselected
	localbrshowlselected = localbrrefdo git rev-range-this-branch --branch {} --any show --color=alwayslselected
	localbrlog = localbrrefdo git rev-range-this-branch --branch {} --any log --color=always
	localbrlogv = localbrrefdo git rev-range-this-branch --branch {} --any logv --color=always
	localbrglog = localbrrefdo git rev-range-this-branch --branch {} --any glog
	localbrlogg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last logg
	localbrlgg = localbrrefdo git rev-range-this-branch --branch {} --any --keep-last lgg
	localbrl = localbrrefdo git rev-range-this-branch --branch {} --any l
	localbrlmine = localbrrefdo git rev-range-this-branch --branch {} --any lmine
	localbrlteam = localbrrefdo git rev-range-this-branch --branch {} --any lteam
	localbrlby = localbrrefdo git dashdash-default-command : rev-range-this-branch --branch {} --any others-command l :
	localbrlg = localbrrefdo git rev-range-this-branch --branch {} --any lg
	localbrlgn = localbrrefdo git rev-range-this-branch --branch {} --any lg
	localbrlgv = localbrrefdo git rev-range-this-branch --branch {} --any lgv
	localbrlh = localbrrefdo git rev-range-this-branch --branch {} --any lh --reverse
	localbrlhmine = localbrrefdo git rev-range-this-branch --branch {} --any lhmine --reverse
	localbrlhteam = localbrrefdo git rev-range-this-branch --branch {} --any lhteam --reverse
	localbrlhby = localbrrefdo git dashdash-default-command : rev-range-this-branch --branch {} --any others-command lh --reverse :
	localbrlurl = localbrrefdo git rev-range-this-branch --branch {} --any lurl
	localbrlourl = localbrrefdo git rev-range-this-branch --branch {} --any lourl --reverse
	localbrluurl = localbrrefdo git rev-range-this-branch --branch {} --any luurl --reverse
	localbrlourlv = localbrrefdo git rev-range-this-branch --branch {} --any lourlv --reverse
	localbrluurlv = localbrrefdo git rev-range-this-branch --branch {} --any luurlv --reverse
	localbrtreeurl = localbrrefdo git rev-range-this-branch --branch {} --any treeurl
	localbrtreeourl = localbrrefdo git rev-range-this-branch --branch {} --any treeourl --reverse
	localbrtreeuurl = localbrrefdo git rev-range-this-branch --branch {} --any treeuurl --reverse
	localbrtreeourlv = localbrrefdo git rev-range-this-branch --branch {} --any treeourlv --reverse
	localbrtreeuurlv = localbrrefdo git rev-range-this-branch --branch {} --any treeuurlv --reverse
	localbrlgmine = localbrrefdo git rev-range-this-branch --branch {} --any lgmine
	localbrlgteam = localbrrefdo git rev-range-this-branch --branch {} --any lgteam
	localbrlgby = localbrrefdo git dashdash-default-command : rev-range-this-branch --branch {} --any others-command lg :
	localbrlogmine = localbrrefdo git rev-range-this-branch --branch {} --any logmine --color=always
	localbrlogteam = localbrrefdo git rev-range-this-branch --branch {} --any logteam --color=always
	localbrlogby = localbrrefdo git dashdash-default-command : rev-range-this-branch --branch {} --any others-command log --color=always :
	; localbrrevert does not make sense with branch references
	; localbrrevertcommit does not make sense with branch references
	; localbrcorrect does not make sense with branch references
	; localbrfixup does not make sense with branch references
	; localbrrbfixup does not make sense with branch references
	; localbrcommitidentical does not make sense with branch references
	; localbrcommitlike does not make sense with branch references
	; localbrrbi would be a generic implementation of the specialized rebaselocalbr.
	; localbrrbni would be a generic implementation of the specialized rebaselocalbr.
	; localbrwipe does not make sense
	; localbrbase cannot be (easily) passed branch references.
	localbrwhodid = localbrrefdo git files-command whodid brshowfiles
	localbrwhotouched = localbrrefdo git rev-range-this-branch --branch {} --any whodid
	localbrwhatdid = localbrrefdo git rev-range-this-branch --branch {} --any whatdid
	localbractivity = localbrrefdo git rev-range-this-branch --branch {} --any activity
	localbractivitymine = localbrrefdo git rev-range-this-branch --branch {} --any activitymine
	localbractivityteam = localbrrefdo git rev-range-this-branch --branch {} --any activityteam
	localbrlogdistribution = localbrrefdo git rev-range-this-branch --branch {} --any logdistribution
	localbrlogdistributionmine = localbrrefdo git rev-range-this-branch --branch {} --any logdistributionmine
	localbrlogdistributionteam = localbrrefdo git rev-range-this-branch --branch {} --any logdistributionteam
	localbremaillog = localbrrefdo git rev-range-this-branch --branch {} --any email-command log
	localbremaillc = localbrrefdo git rev-range-this-branch --branch {} --any email-command lc
	; localbrreintegrate would cover multiple branches
	; localbrpull-request would cover multiple branches


	last = last-command	; Show last commit info: Hashes and author. Use "git log1" or "git show" for more details.
	lastmine = last-command mine-command ; Show my personal last commit info: Hashes and author.
	lastteam = last-command team-command ; Show my team's last commit info: Hashes and author.
	lastby = last-command others-command ; Show that user(s)' last commit info: Hashes and author.
	changes = diff --name-status -r ; Subversion-like 'svn status' reporting.
	;; tagtype: List only those tags of the passed (annotated or lightweight) type.
	taglist-annotated = tagtype annotated
	taglist-lightweight = tagtype lightweight
	;; describe: Show the most recent tag that is reachable from a commit, in the format <annotated tag>-g<commits on top>-<commit-hash>.
	;; desc: Show current / passed revision relative to the most recent ref that is reachable from a commit, in the format <tag|ref>-g<commits on top>-<commit-hash>[-dirty].
	;; describe-version: Show (only the) most recent annotated tag (used for official versions etc.) that the current / passed revision is based on.
	contained-version = contained-command annotated ; Show (only the) first annotated tag (used for official versions etc.) [that matches GREP-ARGS] that comes after the passed revision, and thus contains it.
	annotate-contained-version = annotate-contained-command version
	;; describe-tag: Show relation to the most recent, also lightweight (used for archiving) tag name for the current / passed revision.
	contained-tag = contained-command describe ; Show relation to the first tag (also lightweight, used for archiving) [that matches GREP-ARGS] that comes after the passed revision, and thus contains it.
	annotate-contained-tag = annotate-contained-command tag
	;; timestamp: Print current build identifier containing the host, relation to previous tag, and build time.
	;; contains: Show in which tag(s) a commit is contained, i.e. in which versions this was shipped, or, if that fails, from which branch it can be reached.

	picks = cherrypicks -v --abbrev=7	; See which changes from the current branch (e.g. feature) are already present in the passed branch (e.g. master).
	;; conflicts: List files with merge conficts.
	;; conflictwipe: Abort the merge conflicts and MERGING / CHERRYPICKING state, e.g. when you want to wipe / change the working copy, anyway, and currently can't because of "error: you need to resolve your current index first".
	; Source: http://akahn.net/2011/10/12/working-through-git-conflicts-in-vim.html
	;; cob: Keep "base", the common ancestor in case of merge conflicts.
	;; coo: Keep "ours", the original one we had (ORIG_HEAD), or the one we're rebasing onto, in case of merge conflicts.
	;; cot: Keep "theirs", the version merged in (MERGE_HEAD), or the one from the branch we're rebasing, in case of merge conflicts.
	;; reflog: Show recorded changes to the tip of a branch, mostly to restore unreachable old commits via head@{1}.
	;; inout: Show incoming and outgoing commit logs between current / passed branch and its remote tracked branch / passed branch / corresponding remote branch of passed remote.
	io = inout

	cleanall = clean -d -x	; Remove all untracked files and directories, restoring a pristine working copy.
	;; lsprivate: Show all non-ignored files not under version control.
	;; rmprivate: Remove all non-ignored files not under version control.

	;; staged: Test whether there are / list staged files in index.
	;; editstage: Directly edit file(s) in the index without modifying the corresponding files in the working copy.
	ei = editstage
	;; editstageselected: Interactively select (from staged files or passed list of files) files (or directly pass N, M, ... selections) to directly edit in the index by number.
	eis = editstageselected
	;; invertstage: Swap staged and unstaged (just updated; pass -A|--all to also include untracked files) changes.
	ii = invertstage
	undelete = checkout HEAD -- ; Undo "git rm <file>"; puts the file back into working copy.
	unstage = reset HEAD --	; Undo "git add <file>"; removes the file from the index, so that it isn't committed. (Alternatively, you can commit a few files via "git commit <file>" directly, bypassing the index.)
	unstagehunk = reset --patch HEAD --	; Interactively cherry-pick and remove individual hunks from the index.
	unstageh = unstagehunk
	;; unstageselected ; Interactively select (from staged files or passed list of files) files (or directly pass N, M, ... selections) to remove from the index by number.
	unstages = unstageselected
	unstageselectedhunk = unstageselected --patch ; Interactively select (from staged files or passed list of files) files (or directly pass N, M, ... selections) to remove individual hunks of from the index by number.
	unstagesh = unstageselectedhunk
	;; uncommit: Cancel the last commit; keep working copy and index. / Remove <path>s from the last commit.
	peel = reset --mixed HEAD^ ; Cancel the last commit also from index; keep only the working copy. With this, you can split a single commit during rebase.
	wipecommit = autostash git wipe HEAD^	; Completely remove the last commit, also from working copy and index. Ensures that the current branch isn't dirty.
	;; wipe: Reset HEAD, working copy and index [to <branch>] [<paths>...]. Ensures that the current branch isn't dirty.
	wipetoselected = selectedcommit-command --single-only wipe	; Reset HEAD, working copy and index to the commit interactively chosen from the commits in the passed <range>.
	wipetoselected7 = wipetoselected --max-count 7
	;; hardreset = reset --hard ; Reset HEAD, working copy and index to <branch>. Destructive without safety check (but needs a passed <commit>)!
	;; reset-to-tracked: Reset my current branch to the HEAD of the tracked branch. Use this when the local branch has been pointed elsewhere (e.g. due to an attempted rebase), and you want to restore the original state. The working copy is left intact.
	reset-back = reset ORIG_HEAD	; Undo a previous git reset; allows you to go back into the future after moving the HEAD to the past.
	track = branch --set-upstream-to	; Change the remote the current branch is tracking.
	;; tracks: Show which remote branch is tracked by the current branch.
	;
	;; pushall: Push all branches, tags, and notes (if exist).
	;; up: Pull and rebase the current branch from passed <remote>. (By default, pull prefers merges over rebasing). Handles a dirty working copy by temporarily stashing it. Shows a log of pulled changes.
	pull = pull --ff-only	; Get and fast-forward changes; don't merge or rebase. Let's do that explicitly via the corresponding commands.
	;; rtrack: Make the current branch track in the passed <remote> the passed <branch> / eponymous branch.
	rb = rebase
	rbi = rebase -i
	;; rbni: Interactive rebase without invoking the editor. Use for trivial rebases like squash/fixup commits.
	; brrbi et al: see above
	rbc = rebase --continue	; Commit (after adding resolved conflicts) and continue with any subsequent commits to be cherry-picked.
	rbnc = -c core.editor=true rebase --continue	; Commit without re-editing the message and continue with any subsequent commits to be cherry-picked.
	;; rbcu: addu + rbc: Stage modified files (i.e. those with resolved conflicts) and continue rebasing.
	;; rbcnu: addu + rbnc: Stage modified files (i.e. those with resolved conflicts) and continue rebasing without re-editing the commit message.
	rbs = rebase --skip	; Skip the current patch (as if you had deleted the line).
	rbq = rebase --abort	; Cancel the operation and return to the pre-sequence state.
	rbe = rebase --edit-todo	; Edit the todo list during an interactive rebase.
	rbu = reset @{1}	; Undo the last rebase commit. Effectively squashes this patch with the previous one.
	;; git rebase HEAD <feature> && git rebase HEAD @{-2}: Rebase <feature> to current branch and merge back to current
	;; git rebase master --onto <newbase> <=> git bmrbi --onto <newbase>:	Rebase the changes in the current branch (with regards to master) to appear as if they were committed onto <newbase>. Can be used to move a set of commits to another base commit.
	;; git rebase HEAD^ --onto <newbase>:	Rebase the last commit to appear as if they were committed onto <newbase>.
	;; git rebaselocalbr: Rebase all / the last committed N local branches (except for the current branch and master (and base branch if defined)) to the updated passed (or configured in branch.<name>.remote and branch.<name>.merge) upstream head.
	;; git merge --squash: Create a single commit on top of the current branch whose effect is the same as merging the other branch. Shorter form of interactive rebasing where you choose squash for all following commits.

	; merging
	;; ismerge: Test whether the last commit / <commit> has been created by a merge.
	;; checkout --ours:   (or git coo) will keep the original one we had (ORIG_HEAD) in case of merge conflict
	mergeo = merge --strategy=recursive --strategy-option=ours	; merge that forces conflicting hunks to be auto-resolved cleanly by favoring our version. Changes from the other tree that do not conflict with our side are reflected in the merge result.
	;; checkout --theirs: (or git cot) will keep the version merged in (MERGE_HEAD) in case of merge conflict
	merget = merge --strategy=recursive --strategy-option=theirs	; merge that forces conflicting hunks to be auto-resolved cleanly by favoring the other tree's version. Changes from our side that do not conflict with the other tree are reflected in the merge result.
	;;; mergedryrun: Test whether a merge will do through or cause conflicts without actually doing the merge.
	;; mergeto: Merge the current branch to <target-branch>.
	mergelb = merge @{-1}
	mergedrlb = mergedryrun @{-1}
	mergem = master-command mergeto
	mergen = base-command mergeto
	;; mergelocalbr: Merge all / the last committed N local branches (except for the current branch and master (and base branch if defined)).
	;; mergelocalbrc: Merge all / the last committed N local branches (except for the current branch and master (and base branch if defined)) ordered by date of first commit.
	mt = mergetool
	;; merge-base: Identify branch point (common ancestor).
	; The fast-forward command does the second part of git pull, it merges the
	; remote tracking branch. Use this when you've already fetched the changes
	; (to avoid the superfluous network exchange), and you get the message "Your
	; branch is behind 'origin/tracked-branch', and can be fast-forwarded."
	; after switching to a branch.
	; The --ff is the default, but specify it in case it has been overridden by
	; local config.
	fast-forward = -c merge.defaultToUpstream=true merge --ff
	ff = -c merge.defaultToUpstream=true merge --ff
	fflb = ff @{-1}
	;; mergesummary: Show enriched log (for passed remote) of the passed merge commit, including URLs to the merge commit, the merged changes, full commit message, and changed files.
	omergesummary = mergesummary origin
	umergesummary = mergesummary upstream
	;; unmerge: Undo the merge done in the last commit of the current branch, and checkout the original unmerged branch again.
	;; mergeamend: Commit the staged changes to the (revived) branch that was merged into the last commit of the current branch, and merge it again.

	noff = merge --no-ff
	nofflb =noff @{-1}
	;; reintegrate: Merge / rebase <branch> to the current branch, then delete it from the local repository as well as a tracked remote (if it exists there).
	;; reintegratelb: Merge / rebase the last checked-out branch to the current branch, then delete it from the local repository as well as a tracked remote (if it exists there).
	;; reintegrateto: Merge / rebase the current branch to the passed <branch>, then delete it from the local repository as well as a tracked remote (if it exists there).
	;; reintegratetolb: Merge / rebase the current branch to the last checked-out branch, then delete it from the local repository as well as a tracked remote (if it exists there).

	fl = git-rev-fetch-command l --reverse ; l of fetched commits
	flc = git-rev-fetch-command lc --reverse ; lc of fetched commits
	flg = git-rev-fetch-command lg --reverse ; lg of fetched commits
	flog = git-rev-fetch-command log --reverse ; log of fetched commits
	fetched = diff --stat ..FETCH_HEAD	; Summary of all fetched commits.
	;; remote show <repo>: Remote repository info, including tracked remote branches.
	fetchall = remote update	; Fetch all configured remotes (except when remote.<name>.skipDefaultUpdate is configured).
	;; fetchdate: Show when (any) remote was last fetched.
	;; pushdate: Show when the current branch was last synchronized (pushed or pulled) with the tracked remote branch / passed remote.
	opushdate = pushdate origin
	upushdate = pushdate upstream
	;; updatedate: Show when the last update of the local repository (fetch or push) happened.
	;; uptodate: Check remote whether the current branch is on the same commit as the tracked remote branch / passed remote (or whether a fetch / push is needed).
	ouptodate = uptodate origin
	uuptodate = uptodate upstream

	tco = rev-tracked-command checkout ; checkout tracked branch HEAD
	tdiff = rev-tracked-command diff ; diff with tracked branch
	tdifftool = rev-tracked-command difftool
	tl = rev-tracked-command l ; l of tracked branch
	tlc = rev-tracked-command lc ; lc of tracked branch
	tlg = rev-tracked-command lg ; lg of tracked branch
	tlog = rev-tracked-command log ; log of tracked branch
	treset = reset-to-tracked --must-be-origin	; Reset my current branch (and working tree with --hard) to the HEAD of tracked branch of origin. Use this when the local branch has been pointed elsewhere (e.g. due to an attempted rebase), and you want to restore the original state. The working copy is left intact.
	tmerge = rev-tracked-command merge ; Merge changes in tracked branch with my local repo.
	tmergedr = rev-tracked-command mergedryrun ; Test merge of changes in tracked branch with my local repo.
	trb = rev-tracked-command rebase ; Rebase my commits on top of the tracked branch.
	trbi = rev-tracked-command rebase -i
	trbni = rev-tracked-command rbni

	obrowse = rbrowse origin
	oexists = existsremote origin
	obr = rbr origin ; List all branches in my GitHub clone [matching <pattern>].
	obra = bra --remote origin
	oco = rco origin ; Checkout local branch from origin.
	ocolatest = rcolatest origin ; Checkout local branch from latest (by sort order) branch in my GitHub clone [matching pattern].
	ocolatestc = rcolatestc origin ; Checkout local branch from my GitHub clone's branch [matching pattern] that was created last (except the current branch and master (and base branch if defined)).
	;; ocreatelocalbr: Create (and track) local branches for all branches in origin (matching PATTERN).
	;; oprune: Remove old local branches that do not exist in origin any more.
	omdiff = master-command -1 MASTER..origin/MASTER diff ; Show differences introduced in my GitHub clone relative to master.
	omdifftool = master-command -1 MASTER..origin/MASTER difftool
	ondiff = base-command -1 BASE..origin/BASE diff ; Show differences introduced in my GitHub clone relative to the base branch.
	ondifftool = base-command -1 BASE..origin/BASE difftool
	odiff = rev-remote-command origin diff ; Show differences to my GitHub clone.
	odifftool = rev-remote-command origin difftool ; Show differences to my GitHub clone.
	ol = rev-remote-command origin l; l of origin
	olc = rev-remote-command origin lc; lc of origin
	olg = rev-remote-command origin lg; lg of origin
	olog = rev-remote-command origin log; Log of my GitHub clone.
	oio = inout origin
	omio = master-command -2 MASTER origin/MASTER inout
	onio = base-command -2 BASE origin/BASE inout
	omrb = master-command -2 MASTER origin/MASTER remaster ; Remaster my commits on top of the latest master of my GitHub clone.
	onrb = base-command -2 BASE origin/BASE rebase ; Rebase my commits on top of the latest base branch of my GitHub clone.
	ofetch = fetch origin ; Get changes done to my GitHub clone through another Git repository, e.g. from another system. Use this, followed by git owipe, when origin has been reset (e.g. to an updated upstream).
	opull = pull --ff-only origin ; Get and fast-forward changes done to my GitHub clone through another Git repository, e.g. from another system. This allows to either merge or rebase (recommended) when local commits have been done to an outdated local branch.
	oup = up origin
	omerge = rev-remote-command origin merge ; Merge changes done to my GitHub clone through another Git repository with my local repo.
	omergedr = rev-remote-command origin mergedryrun ; Test merge of changes done to my GitHub clone through another Git repository with my local repo.
	orb = rev-remote-command origin rebase ; Rebase my commits on top of the corresponding branch in my GitHub clone (or passed <branch>).
	orbi = rev-remote-command origin rebase -i
	orbni = rev-remote-command origin rbni
	opa = pushall origin	; Push all branches, tags, and notes (if exist) to origin.
	opush = push origin ; Re-publish of current / passed <branch> to the tracking GitHub clone to get them pulled into upstream.
	opublish = rpublish origin ; Initial publish of current / passed <branch> to my GitHub clone to get them pulled into upstream.
	; ... and set upstream tracking reference so that future pushes can omit the branch name (when push.default=tracking).
	; Instead, I could probably also setup automatic tracking, but:
	; - would lose the warning when trying to opush a branch that I haven't
	;   published yet.
	; - would default to pushing to foreign branches from someone (which I'm
	;   not allowed), instead of being forced to publish to my own GitHub
	;   clone.
	;
	;   git config branch.autosetupmerge true
	; tells git-branch and git-checkout to setup new branches so that git-pull(1)
	; will appropriately merge from that remote branch.  Recommended.  Without this,
	; you will have to add --track to your branch command or manually merge remote
	; tracking branches with "fetch" and then "merge".
	odeletebr = push origin --delete ; Delete remote <branch> in my GitHub clone. Older git must use "push origin :BRANCHNAME"
	oldeletebr = rldeletebr origin ; Delete <branch> from the local repository as well as origin.
	oldeletelb = rldeletebr origin @{-1} ; Delete the last checked-out branch from the local repository as well as origin.
	olrenamebr = rlrenamebr origin ; Rename current / <oldbranch> to <newbranch> in both local repository and origin.
	oreset = rev-remote-command origin reset ; Reset my current branch to the HEAD of the corresponding / passed branch of origin. The working copy is left intact, so you can effectively rebase any outstanding differences with a follow-up commit.
	ohardreset = rev-remote-command origin reset --hard ; Reset my current branch to the HEAD of the corresponding / passed branch of upstream.
	otrack = rtrack origin	; Make the current branch track the eponymous branch in origin.
	oremotebr = remotebr origin	; Print corresponding origin/branch for the current / passed branch(es) (or return error).
	oreset = rev-remote-command origin reset ; Reset my current branch to the HEAD of the corresponding / passed branch in origin.
	owipe = rev-remote-command origin wipe ; Reset my current branch to the HEAD of the corresponding / passed branch of origin. Use this after an ureset done in another repository. Ensures that the current branch isn't dirty.

	; How to add the upstream repository to my own repository:
	;	git remote add upstream http://repo.or.cz/r/vcscommand.vim.git
	; Note: HTTPS is the default, but I've seen failures behind the corporate
	; firewall. On there other hand, I got a 403 when using HTTP.
	ubrowse = rbrowse upstream
	uexists = existsremote upstream
	ubr = rbr upstream ; List all branches in upstream [matching <pattern>].
	ubra = bra --remote upstream
	upicks = rev-remote-command upstream cherrypicks -v --abbrev=7 ; See which changes from the current branch are already present upstream.
	uco = rco upstream ; Checkout local branch from upstream.
	ucolatest = rcolatest upstream ; Checkout local branch from latest (by sort order) upstream [matching pattern].
	ucolatestc = rcolatestc upstream ; Checkout local branch from the upstream branch [matching pattern] that was created last (except the current branch and master (and base branch if defined)).
	ucom = master-command -1 upstream/MASTER checkout ; Use with -b <newbranch> to start a patch based on the current upstream.
	ucon = base-command -1 upstream/BASE checkout ; Use with -b <newbranch> to start a patch based on the current upstream's base branch.
	;; uprune: Remove old local branches that do not exist in upstream any more.
	umdiff = master-command -1 MASTER..upstream/MASTER diff ; Show differences introduced in upstream relative to master; useful to review upstream changes before pulling them in.
	umdifftool = master-command -1 MASTER..upstream/MASTER difftool
	undiff = base-command -1 BASE..upstream/BASE diff ; Show differences introduced in upstream relative to the base branch; useful to review upstream changes before pulling them in.
	undifftool = base-command -1 BASE..upstream/BASE difftool
	udiff = rev-remote-command upstream diff ; Show differences to upstream.
	udifftool = rev-remote-command upstream difftool
	ul = rev-remote-command upstream l ; l of upstream
	ulc = rev-remote-command upstream lc ;: lc of upstream
	ulg = rev-remote-command upstream lg ;: lg of upstream
	ulog = rev-remote-command upstream log ; Log of upstream.
	umlog = master-command --keep-position rev-branch-remotebr-command upstream MASTER log ; Show log of changes introduced in upstream relative to master; useful to review upstream changes before pulling them in.
	unlog = base-command --keep-position rev-branch-remotebr-command upstream BASE log ; Show log of changes introduced in upstream relative to base; useful to review upstream changes before pulling them in.
	umlg = master-command --keep-position rev-branch-remotebr-command upstream MASTER lg ; Show one-line log of changes introduced in upstream relative to master; useful to review upstream changes before pulling them in.
	unlg = base-command --keep-position rev-branch-remotebr-command upstream BASE lg ; Show one-line log of changes introduced in upstream relative to base; useful to review upstream changes before pulling them in.
	umlc = master-command --keep-position rev-branch-remotebr-command upstream MASTER lc ; Show log and diff of changes introduced in upstream relative to master; useful to review upstream changes before pulling them in.
	unlc = base-command --keep-position rev-branch-remotebr-command upstream BASE lc ; Show log and diff of changes introduced in upstream relative to base; useful to review upstream changes before pulling them in.
	uio = inout upstream
	umio = master-command -2 MASTER upstream/MASTER inout
	unio = base-command -2 BASE upstream/BASE inout
	umrb = master-command -1 upstream/MASTER rebase ; Rebase my commits on top of the latest main upstream branch. "co mybranch" first, clone it via "git co -b mybranch-old; git opublish" if you want to keep the old one, or just use "umrb mybranch". You can also do this after the rebase, but before pushing: "git tco -b mybranch-old; git opublish; git co mybranch". Persist with "git opush -f"; undo with "git treset --hard".
	unrb = base-command -1 upstream/BASE rebase ; Rebase my commits on top of the latest base upstream branch.
	ufetch = fetch upstream	; Get upstream changes.
	;; upull: Get and fast-forward upstream changes. (With proper use of other branches for patches, there should not be a need to merge upstream.) Use for direct checkouts of upstream, without my own origin. Else, prefer ucatchup.
	;; upush: push upstream ; Directly push current / passed <branch> to upstream.
	upublish = rpublish upstream ; Initial publish of current / passed <branch> directly to upstream (without using an origin clone (for now)).
	;; uopush: push upstream + origin; Directly push current / passed <branch> to upstream and (if successful) push it to the tracking GitHub clone, too.
	;; uup: up upstream
	umerge = rev-remote-command upstream merge ; Merge upstream changes with my local repo.
	umergedr = rev-remote-command upstream mergedryrun ; Test merge of upstream changes with my local repo.
	urb = rev-remote-command upstream rebase ; Rebase my commits on top of the corresponding branch in upstream (or passed <branch>).
	urbi = rev-remote-command upstream rebase -i
	urbni = rev-remote-command upstream rbni
	;; urebaselocalbr: Rebase all / the last committed N local branches (except for the current branch and master (and base branch if defined)) to the updated upstream head. After that, merge again via git uwipem && git mergelocalbrc; then use git opush -f --all to send the rebased branches to origin.
	; To make pull default to rebase instead of merge, can use these:
	; # make "git pull" on master always use rebase
	; $ git config branch.master.rebase true
	; You can also set up a global option to set the last property for every
	; new tracked branch:
	; # setup rebase for every tracking branch
	; $ git config --global branch.autosetuprebase always
	; Source: http://mislav.uniqpath.com/2010/07/git-tips/
	;; ufetchup-localbr: Fetch all upstream changes and then rebase all / the last committed N local branches (using a separate worktree we're not on master, suppressing standard fetch / rebase information and messages when there are no changes in upstream).
	udeletebr = push upstream --delete ; Delete remote <branch> in upstream. Older git must use "push origin :BRANCHNAME"
	uldeletebr = rldeletebr upstream ; Delete <branch> from the local repository as well as upstream.
	ulrenamebr = rlrenamebr upstream ; Rename current / <oldbranch> to <newbranch> in both local repository and upstream.

	;; oadd: Add origin repository and fetch it. Offers to rename original origin to upstream.
	uadd = remote add -f upstream	; Add upstream repository and fetch it.
	radd = remote add -f	; Add remote repository and fetch it.
	; other foreign repositories
	; To import someone's repository and work on it, do this:
	;   # Import.
	;   git remote add -f <someone> https://github.com/<someone>/<project>.git
	;   # The -f already did: git fetch <someone>
	;   # What has changed in his branch?
	;   git diff upstream/master..<someone>/<branch>
	;   git co -b <branch> <someone>/<branch>
	;   # Do changes ...
	;   # Publish to your GitHub clone to make the changes accessible to someone.
	;   git opublish <branch>
	uremotebr = remotebr upstream	; Print corresponding upstream/branch for the current / passed branch(es) (or return error).
	ureset = rev-remote-command upstream reset ; Reset my current branch to the HEAD of the corresponding / passed branch of upstream. Use this after my pull requests have been accepted into upstream (but cherry-picked, in a different order, or intermingled with other requests, so that the commit history deviates from mine), but there are still pending changes. The working copy is left intact, so you can effectively rebase any outstanding differences with a follow-up commit.
	uhardreset = rev-remote-command upstream reset --hard ; Reset my current branch to the HEAD of the corresponding / passed branch of upstream.
	uwipe = rev-remote-command upstream wipe ; Reset my current branch to the HEAD of the corresponding / passed branch of upstream. Ensures that the current branch isn't dirty.
	;; uwipem: Switch to my master branch and reset it to the HEAD of the upstream/master.
	;; uwipen: Switch to my base branch and reset it to the HEAD of the upstream/base.
	;; urestore: Reset my current branch to the HEAD of the current / passed branch of upstream, and push this to my GitHub clone. Use this after my pull requests have been accepted into upstream (but cherry-picked, in a different order, or intermingled with other requests, so that the commit history deviates from mine). Ensures that the current branch isn't dirty.
	;; ucatchup: uup + urestore; Pull and rebase upstream changes (onto potentially dirty working copy), and push this to my GitHub clone. Use this when you directly follow upstream, and want to update your repo to its most recent version.
	;; ucatchup-hushed: Variant of ucatchup that suppresses standard fetch / rebase information and messages when there are no changes in upstream. Useful when updating many repositories e.g. with git-wcdo.
	;; ufetchup: ufetch + uup + urestore; Fetch all upstream changes, then pull and rebase (onto potentially dirty working copy), and push this to my GitHub clone. Use this when you directly follow all concurrent activity in upstream, and want to update your repo to its most recent version.
	;; ufetchup-hushed: Variant of ufetchup that suppresses standard fetch / rebase information and messages when there are no changes in upstream. Useful when updating many repositories e.g. with git-wcdo.
	;; ufetchup-branch: Variant of ufetchup-hushed that fetches all upstream changes and always pulls the passed branch (using a separate worktree if the branch isn't the current one, suppressing standard fetch / rebase information and messages when there are no changes in upstream) and then pushes this branch to my GitHub clone. Useful when updating many repositories e.g. with git-wcdo.
	ufetchupm = master-command ufetchup-branch	; Fetch all upstream changes and then rebase the master branch (using a separate worktree if a different is checked out, suppressing standard fetch / rebase information and messages when there are no changes in upstream) and then push this to my GitHub clone.

	; How to create a new GitHub repository:
	; 1. git init myproject
	; 2. On GitHub, create a new repository.
	; 3. git remote add origin git@github.com:inkarkat/myproject.git
	; 4. git push -u origin master
	;
	; with the hub extension:
	; 2. [git cd]
	; 3. git create -d "description"
	; 4. git opublish
	;
	; How to fork a non-GitHub repository:
	; 1. git clone --origin=upstream http://repo.or.cz/r/vcscommand.vim.git
	; 2. On GitHub, create a new repository.
	; 3. cd vcscommand.git
	; 4. git remote add origin git@github.com:inkarkat/vcscommand.vim.git
	; 5. git push -u origin master

	;; writebackup-import: Import a directory hierarchy into Git, using existing backup files with a current date file extension as history.
	;; writebackup-ingo-import: Import a directory hierarchy into Git, extracting the commit messages from ingo's custom changelog file header from existing backup files with a current date file extension as history.
	;; remotes: Show remotes with URLs.
	;; remote-url: Show URL of <name> (as HTTPS, even if SSH access is configured). ("hub browse -u" apparently only can do this for origin.)
	ourl = remote-url origin
	uurl = remote-url upstream
	;; remote-isreadonly: Test whether there's a push URL for <name>, or whether that remote is read-only (i.e. there's only a fetch URL).
	uisreadonly = remote-isreadonly upstream
	;; remote-setreadonly: Removes the push URL for <name>, which disables pushes to it. It can only be fetched from, until the push URL is restored to the fetch URL.
	usetreadonly = remote-setreadonly upstream
	;; existsremote: Check whether the passed remote has been configured in the working copy.
	;; existsremoteurl: Check whether the passed remote name / URL offers a remote repository.

	; Submodule handling; taken from http://git-scm.com/book/en/v2/Git-Tools-Submodules
	;; subdiff: Show diff of repository and any submodules, too.
	subpush = push --recurse-submodules=on-demand	; Goes into each submodule and manually pushes to the remotes to make sure they're externally available.
	subupdate = submodule update --remote --merge	; Update and merge our changes with upstream changes to the submodule.


	;; Git Flow
	feat = flow feature
	;; feat-start: Finish feature <name> / the feature that was developed on the current feature branch.
	;; feat-fromcommit: Start a new feature <name>, and incorporate the last commit / all commits up to and including <commit>, which is/are then removed from the current branch so that it/they will exclusively reside on the new feature branch.
	;; feat-co: Abbreviation of "feature checkout".
	;; release: flow release
	;; release-commit: Do the release commit (that updates the changelog etc.) with an auto-generated commit message for the current release.
	bug = flow bugfix
	hf = flow hotfix


	;; cr: Show GitHub issues and pull requests (separately).
	;; crrecent: Show recently (default 2 weeks) updated GitHub issues and pull requests (separately), including the relative creation date.
	;; crstatus: Show number of issues and pull requests.
	myissues = me-in-github-command --assignee= issue
	issuesfromme = me-in-github-command --creator= issue
	issuesaboutme = me-in-github-command --mentioned= issue
	mycrs = me-in-github-command --assignee= cr
	crsfromme = me-in-github-command --creator= cr
	crsaboutme = me-in-github-command --mentioned= cr
	myprs = me-in-github-command --assignee= pr
	prsfromme = me-in-github-command --creator= pr
	prsaboutme = me-in-github-command --mentioned= pr
	;; reviews: Show pull requests with open reviews.
	myreviews = me-in-github-command --reviewer= reviews
	reviewsofprsfromme = me-in-github-command --creator= reviews
	reviewsofmyprs = me-in-github-command --assignee= reviews
	;; prtitle: Obtain corresponding GitHub pull request(s) that have <commit>(s) as the branch's HEAD, and print its title(s; on separate lines, with a summary header listing the PR numbers followed by an empty line) then.

[difftool "diffc"]
	cmd = git-diffc --as-difftool "$LOCAL" "$REMOTE"
[difftool "diffy"]
	cmd = git-diffY --as-difftool --suppress-common-lines "$LOCAL" "$REMOTE"
[difftool "diffY"]
	cmd = git-diffY --as-difftool "$LOCAL" "$REMOTE"