diff --git a/Library/Homebrew/cmd/update.sh b/Library/Homebrew/cmd/update.sh
index 837dfa8bbc..6d1e74f1ed 100644
--- a/Library/Homebrew/cmd/update.sh
+++ b/Library/Homebrew/cmd/update.sh
@@ -9,31 +9,38 @@
 #:      -d, --debug                      Display a trace of all shell commands as they are executed.
 #:      -h, --help                       Show this message.
 
-source "$HOMEBREW_LIBRARY/Homebrew/utils/lock.sh"
+# HOMEBREW_CURLRC, HOMEBREW_DEVELOPER, HOMEBREW_GIT_EMAIL, HOMEBREW_GIT_NAME
+# HOMEBREW_UPDATE_CLEANUP, HOMEBREW_UPDATE_TO_TAG are from the user environment
+# HOMEBREW_LIBRARY, HOMEBREW_PREFIX, HOMEBREW_REPOSITORY are set by bin/brew
+# HOMEBREW_BREW_DEFAULT_GIT_REMOTE, HOMEBREW_BREW_GIT_REMOTE, HOMEBREW_CACHE, HOMEBREW_CELLAR, HOMEBREW_CURL
+# HOMEBREW_DEV_CMD_RUN, HOMEBREW_FORCE_BREWED_CURL, HOMEBREW_FORCE_BREWED_GIT, HOMEBREW_SYSTEM_CURL_TOO_OLD
+# HOMEBREW_USER_AGENT_CURL are set by brew.sh
+# shellcheck disable=SC2154
+source "${HOMEBREW_LIBRARY}/Homebrew/utils/lock.sh"
 
 # Replaces the function in Library/Homebrew/brew.sh to cache the Git executable to
 # provide speedup when using Git repeatedly (as update.sh does).
 git() {
-  if [[ -z "$GIT_EXECUTABLE" ]]
+  if [[ -z "${GIT_EXECUTABLE}" ]]
   then
-    GIT_EXECUTABLE="$("$HOMEBREW_LIBRARY/Homebrew/shims/scm/git" --homebrew=print-path)"
+    GIT_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/scm/git" --homebrew=print-path)"
   fi
-  "$GIT_EXECUTABLE" "$@"
+  "${GIT_EXECUTABLE}" "$@"
 }
 
 git_init_if_necessary() {
-  safe_cd "$HOMEBREW_REPOSITORY"
+  safe_cd "${HOMEBREW_REPOSITORY}"
   if [[ ! -d ".git" ]]
   then
     set -e
     trap '{ rm -rf .git; exit 1; }' EXIT
     git init
     git config --bool core.autocrlf false
-    if [[ "$HOMEBREW_BREW_DEFAULT_GIT_REMOTE" != "$HOMEBREW_BREW_GIT_REMOTE" ]]
+    if [[ "${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_BREW_GIT_REMOTE}" ]]
     then
-      echo "HOMEBREW_BREW_GIT_REMOTE set: using $HOMEBREW_BREW_GIT_REMOTE for Homebrew/brew Git remote URL."
+      echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} for Homebrew/brew Git remote URL."
     fi
-    git config remote.origin.url "$HOMEBREW_BREW_GIT_REMOTE"
+    git config remote.origin.url "${HOMEBREW_BREW_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force --tags origin
     git remote set-head origin --auto >/dev/null
@@ -43,19 +50,19 @@ git_init_if_necessary() {
     trap - EXIT
   fi
 
-  [[ -d "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" ]] || return
-  safe_cd "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core"
+  [[ -d "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" ]] || return
+  safe_cd "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core"
   if [[ ! -d ".git" ]]
   then
     set -e
     trap '{ rm -rf .git; exit 1; }' EXIT
     git init
     git config --bool core.autocrlf false
-    if [[ "$HOMEBREW_CORE_DEFAULT_GIT_REMOTE" != "$HOMEBREW_CORE_GIT_REMOTE" ]]
+    if [[ "${HOMEBREW_CORE_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_CORE_GIT_REMOTE}" ]]
     then
-      echo "HOMEBREW_CORE_GIT_REMOTE set: using $HOMEBREW_CORE_GIT_REMOTE for Homebrew/core Git remote URL."
+      echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} for Homebrew/core Git remote URL."
     fi
-    git config remote.origin.url "$HOMEBREW_CORE_GIT_REMOTE"
+    git config remote.origin.url "${HOMEBREW_CORE_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force origin refs/heads/master:refs/remotes/origin/master
     git remote set-head origin --auto >/dev/null
@@ -70,28 +77,28 @@ repo_var() {
   local repo_var
 
   repo_var="$1"
-  if [[ "$repo_var" = "$HOMEBREW_REPOSITORY" ]]
+  if [[ "${repo_var}" = "${HOMEBREW_REPOSITORY}" ]]
   then
     repo_var=""
   else
-    repo_var="${repo_var#"$HOMEBREW_LIBRARY/Taps"}"
-    repo_var="$(echo -n "$repo_var" | tr -C "A-Za-z0-9" "_" | tr "[:lower:]" "[:upper:]")"
+    repo_var="${repo_var#"${HOMEBREW_LIBRARY}/Taps"}"
+    repo_var="$(echo -n "${repo_var}" | tr -C "A-Za-z0-9" "_" | tr "[:lower:]" "[:upper:]")"
   fi
-  echo "$repo_var"
+  echo "${repo_var}"
 }
 
 upstream_branch() {
   local upstream_branch
 
   upstream_branch="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null)"
-  if [[ -z "$upstream_branch" ]]
+  if [[ -z "${upstream_branch}" ]]
   then
     git remote set-head origin --auto >/dev/null
     upstream_branch="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null)"
   fi
   upstream_branch="${upstream_branch#refs/remotes/origin/}"
-  [[ -z "$upstream_branch" ]] && upstream_branch="master"
-  echo "$upstream_branch"
+  [[ -z "${upstream_branch}" ]] && upstream_branch="master"
+  echo "${upstream_branch}"
 }
 
 read_current_revision() {
@@ -99,10 +106,10 @@ read_current_revision() {
 }
 
 pop_stash() {
-  [[ -z "$STASHED" ]] && return
-  if [[ -n "$HOMEBREW_VERBOSE" ]]
+  [[ -z "${STASHED}" ]] && return
+  if [[ -n "${HOMEBREW_VERBOSE}" ]]
   then
-    echo "Restoring your stashed changes to $DIR..."
+    echo "Restoring your stashed changes to ${DIR}..."
     git stash pop
   else
     git stash pop "${QUIET_ARGS[@]}" 1>/dev/null
@@ -111,26 +118,26 @@ pop_stash() {
 }
 
 pop_stash_message() {
-  [[ -z "$STASHED" ]] && return
-  echo "To restore the stashed changes to $DIR, run:"
-  echo "  cd $DIR && git stash pop"
+  [[ -z "${STASHED}" ]] && return
+  echo "To restore the stashed changes to ${DIR}, run:"
+  echo "  cd ${DIR} && git stash pop"
   unset STASHED
 }
 
 reset_on_interrupt() {
-  if [[ "$INITIAL_BRANCH" != "$UPSTREAM_BRANCH" && -n "$INITIAL_BRANCH" ]]
+  if [[ "${INITIAL_BRANCH}" != "${UPSTREAM_BRANCH}" && -n "${INITIAL_BRANCH}" ]]
   then
-    git checkout "$INITIAL_BRANCH" "${QUIET_ARGS[@]}"
+    git checkout "${INITIAL_BRANCH}" "${QUIET_ARGS[@]}"
   fi
 
-  if [[ -n "$INITIAL_REVISION" ]]
+  if [[ -n "${INITIAL_REVISION}" ]]
   then
     git rebase --abort &>/dev/null
     git merge --abort &>/dev/null
-    git reset --hard "$INITIAL_REVISION" "${QUIET_ARGS[@]}"
+    git reset --hard "${INITIAL_REVISION}" "${QUIET_ARGS[@]}"
   fi
 
-  if [[ -n "$HOMEBREW_NO_UPDATE_CLEANUP" ]]
+  if [[ -n "${HOMEBREW_NO_UPDATE_CLEANUP}" ]]
   then
     pop_stash
   else
@@ -150,28 +157,28 @@ simulate_from_current_branch() {
   local CURRENT_REVISION
 
   DIR="$1"
-  cd "$DIR" || return
+  cd "${DIR}" || return
   TAP_VAR="$2"
   UPSTREAM_BRANCH="$3"
   CURRENT_REVISION="$4"
 
-  INITIAL_REVISION="$(git rev-parse -q --verify "$UPSTREAM_BRANCH")"
-  export HOMEBREW_UPDATE_BEFORE"$TAP_VAR"="$INITIAL_REVISION"
-  export HOMEBREW_UPDATE_AFTER"$TAP_VAR"="$CURRENT_REVISION"
-  if [[ "$INITIAL_REVISION" != "$CURRENT_REVISION" ]]
+  INITIAL_REVISION="$(git rev-parse -q --verify "${UPSTREAM_BRANCH}")"
+  export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${INITIAL_REVISION}"
+  export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}"
+  if [[ "${INITIAL_REVISION}" != "${CURRENT_REVISION}" ]]
   then
     HOMEBREW_UPDATED="1"
   fi
-  if ! git merge-base --is-ancestor "$INITIAL_REVISION" "$CURRENT_REVISION"
+  if ! git merge-base --is-ancestor "${INITIAL_REVISION}" "${CURRENT_REVISION}"
   then
-    odie "Your $DIR HEAD is not a descendant of $UPSTREAM_BRANCH!"
+    odie "Your ${DIR} HEAD is not a descendant of ${UPSTREAM_BRANCH}!"
   fi
 }
 
 merge_or_rebase() {
-  if [[ -n "$HOMEBREW_VERBOSE" ]]
+  if [[ -n "${HOMEBREW_VERBOSE}" ]]
   then
-    echo "Updating $DIR..."
+    echo "Updating ${DIR}..."
   fi
 
   local DIR
@@ -179,14 +186,14 @@ merge_or_rebase() {
   local UPSTREAM_BRANCH
 
   DIR="$1"
-  cd "$DIR" || return
+  cd "${DIR}" || return
   TAP_VAR="$2"
   UPSTREAM_BRANCH="$3"
   unset STASHED
 
   trap reset_on_interrupt SIGINT
 
-  if [[ "$DIR" = "$HOMEBREW_REPOSITORY" && -n "$HOMEBREW_UPDATE_TO_TAG" ]]
+  if [[ "${DIR}" = "${HOMEBREW_REPOSITORY}" && -n "${HOMEBREW_UPDATE_TO_TAG}" ]]
   then
     UPSTREAM_TAG="$(git tag --list |
                     sort --field-separator=. --key=1,1nr -k 2,2nr -k 3,3nr |
@@ -195,19 +202,19 @@ merge_or_rebase() {
     UPSTREAM_TAG=""
   fi
 
-  if [ -n "$UPSTREAM_TAG" ]
+  if [ -n "${UPSTREAM_TAG}" ]
   then
-    REMOTE_REF="refs/tags/$UPSTREAM_TAG"
+    REMOTE_REF="refs/tags/${UPSTREAM_TAG}"
     UPSTREAM_BRANCH="stable"
   else
-    REMOTE_REF="origin/$UPSTREAM_BRANCH"
+    REMOTE_REF="origin/${UPSTREAM_BRANCH}"
   fi
 
   if [[ -n "$(git status --untracked-files=all --porcelain 2>/dev/null)" ]]
   then
-    if [[ -n "$HOMEBREW_VERBOSE" ]]
+    if [[ -n "${HOMEBREW_VERBOSE}" ]]
     then
-      echo "Stashing uncommitted changes to $DIR..."
+      echo "Stashing uncommitted changes to ${DIR}..."
     fi
     git merge --abort &>/dev/null
     git rebase --abort &>/dev/null
@@ -217,9 +224,9 @@ merge_or_rebase() {
              stash save --include-untracked "${QUIET_ARGS[@]}"
     then
       odie <<EOS
-Could not 'git stash' in $DIR!
+Could not 'git stash' in ${DIR}!
 Please stash/commit manually if you need to keep your changes or, if not, run:
-  cd $DIR
+  cd ${DIR}
   git reset --hard origin/master
 EOS
     fi
@@ -228,63 +235,63 @@ EOS
   fi
 
   INITIAL_BRANCH="$(git symbolic-ref --short HEAD 2>/dev/null)"
-  if [[ -n "$UPSTREAM_TAG" ]] ||
-     [[ "$INITIAL_BRANCH" != "$UPSTREAM_BRANCH" && -n "$INITIAL_BRANCH" ]]
+  if [[ -n "${UPSTREAM_TAG}" ]] ||
+     [[ "${INITIAL_BRANCH}" != "${UPSTREAM_BRANCH}" && -n "${INITIAL_BRANCH}" ]]
   then
     # Recreate and check out `#{upstream_branch}` if unable to fast-forward
     # it to `origin/#{@upstream_branch}`. Otherwise, just check it out.
-    if [[ -z "$UPSTREAM_TAG" ]] &&
-       git merge-base --is-ancestor "$UPSTREAM_BRANCH" "$REMOTE_REF" &>/dev/null
+    if [[ -z "${UPSTREAM_TAG}" ]] &&
+       git merge-base --is-ancestor "${UPSTREAM_BRANCH}" "${REMOTE_REF}" &>/dev/null
     then
-      git checkout --force "$UPSTREAM_BRANCH" "${QUIET_ARGS[@]}"
+      git checkout --force "${UPSTREAM_BRANCH}" "${QUIET_ARGS[@]}"
     else
-      if [[ -n "$UPSTREAM_TAG" && "$UPSTREAM_BRANCH" != "master" ]]
+      if [[ -n "${UPSTREAM_TAG}" && "${UPSTREAM_BRANCH}" != "master" ]]
       then
         git checkout --force -B "master" "origin/master" "${QUIET_ARGS[@]}"
       fi
 
-      git checkout --force -B "$UPSTREAM_BRANCH" "$REMOTE_REF" "${QUIET_ARGS[@]}"
+      git checkout --force -B "${UPSTREAM_BRANCH}" "${REMOTE_REF}" "${QUIET_ARGS[@]}"
     fi
   fi
 
   INITIAL_REVISION="$(read_current_revision)"
-  export HOMEBREW_UPDATE_BEFORE"$TAP_VAR"="$INITIAL_REVISION"
+  export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${INITIAL_REVISION}"
 
   # ensure we don't munge line endings on checkout
   git config core.autocrlf false
 
-  if [[ -z "$HOMEBREW_MERGE" ]]
+  if [[ -z "${HOMEBREW_MERGE}" ]]
   then
     # Work around bug where git rebase --quiet is not quiet
-    if [[ -z "$HOMEBREW_VERBOSE" ]]
+    if [[ -z "${HOMEBREW_VERBOSE}" ]]
     then
-      git rebase "${QUIET_ARGS[@]}" "$REMOTE_REF" >/dev/null
+      git rebase "${QUIET_ARGS[@]}" "${REMOTE_REF}" >/dev/null
     else
-      git rebase "${QUIET_ARGS[@]}" "$REMOTE_REF"
+      git rebase "${QUIET_ARGS[@]}" "${REMOTE_REF}"
     fi
   else
-    git merge --no-edit --ff "${QUIET_ARGS[@]}" "$REMOTE_REF" \
+    git merge --no-edit --ff "${QUIET_ARGS[@]}" "${REMOTE_REF}" \
       --strategy=recursive \
       --strategy-option=ours \
       --strategy-option=ignore-all-space
   fi
 
   CURRENT_REVISION="$(read_current_revision)"
-  export HOMEBREW_UPDATE_AFTER"$TAP_VAR"="$CURRENT_REVISION"
+  export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}"
 
-  if [[ "$INITIAL_REVISION" != "$CURRENT_REVISION" ]]
+  if [[ "${INITIAL_REVISION}" != "${CURRENT_REVISION}" ]]
   then
     HOMEBREW_UPDATED="1"
   fi
 
   trap '' SIGINT
 
-  if [[ -n "$HOMEBREW_NO_UPDATE_CLEANUP" ]]
+  if [[ -n "${HOMEBREW_NO_UPDATE_CLEANUP}" ]]
   then
-    if [[ "$INITIAL_BRANCH" != "$UPSTREAM_BRANCH" && -n "$INITIAL_BRANCH" &&
-          ! "$INITIAL_BRANCH" =~ ^v[0-9]+\.[0-9]+\.[0-9]|stable$ ]]
+    if [[ "${INITIAL_BRANCH}" != "${UPSTREAM_BRANCH}" && -n "${INITIAL_BRANCH}" &&
+          ! "${INITIAL_BRANCH}" =~ ^v[0-9]+\.[0-9]+\.[0-9]|stable$ ]]
     then
-      git checkout "$INITIAL_BRANCH" "${QUIET_ARGS[@]}"
+      git checkout "${INITIAL_BRANCH}" "${QUIET_ARGS[@]}"
     fi
 
     pop_stash
@@ -302,7 +309,7 @@ homebrew-update() {
 
   for option in "$@"
   do
-    case "$option" in
+    case "${option}" in
       -\?|-h|--help|--usage)          brew help update; exit $? ;;
       --verbose)                      HOMEBREW_VERBOSE=1 ;;
       --debug)                        HOMEBREW_DEBUG=1 ;;
@@ -313,10 +320,10 @@ homebrew-update() {
       --preinstall)                   export HOMEBREW_UPDATE_PREINSTALL=1 ;;
       --*)                            ;;
       -*)
-        [[ "$option" = *v* ]] && HOMEBREW_VERBOSE=1
-        [[ "$option" = *q* ]] && HOMEBREW_QUIET=1
-        [[ "$option" = *d* ]] && HOMEBREW_DEBUG=1
-        [[ "$option" = *f* ]] && HOMEBREW_UPDATE_FORCE=1
+        [[ "${option}" = *v* ]] && HOMEBREW_VERBOSE=1
+        [[ "${option}" = *q* ]] && HOMEBREW_QUIET=1
+        [[ "${option}" = *d* ]] && HOMEBREW_DEBUG=1
+        [[ "${option}" = *f* ]] && HOMEBREW_UPDATE_FORCE=1
         ;;
       *)
         odie <<EOS
@@ -327,14 +334,14 @@ EOS
     esac
   done
 
-  if [[ -n "$HOMEBREW_DEBUG" ]]
+  if [[ -n "${HOMEBREW_DEBUG}" ]]
   then
     set -x
   fi
 
-  if [[ -z "$HOMEBREW_UPDATE_CLEANUP" && -z "$HOMEBREW_UPDATE_TO_TAG" ]]
+  if [[ -z "${HOMEBREW_UPDATE_CLEANUP}" && -z "${HOMEBREW_UPDATE_TO_TAG}" ]]
   then
-    if [[ -n "$HOMEBREW_DEVELOPER" || -n "$HOMEBREW_DEV_CMD_RUN" ]]
+    if [[ -n "${HOMEBREW_DEVELOPER}" || -n "${HOMEBREW_DEV_CMD_RUN}" ]]
     then
       export HOMEBREW_NO_UPDATE_CLEANUP="1"
     else
@@ -343,51 +350,51 @@ EOS
   fi
 
   # check permissions
-  if [[ -e "$HOMEBREW_CELLAR" && ! -w "$HOMEBREW_CELLAR" ]]
+  if [[ -e "${HOMEBREW_CELLAR}" && ! -w "${HOMEBREW_CELLAR}" ]]
   then
     odie <<EOS
-$HOMEBREW_CELLAR is not writable. You should change the
-ownership and permissions of $HOMEBREW_CELLAR back to your
+${HOMEBREW_CELLAR} is not writable. You should change the
+ownership and permissions of ${HOMEBREW_CELLAR} back to your
 user account:
-  sudo chown -R \$(whoami) $HOMEBREW_CELLAR
+  sudo chown -R \$(whoami) ${HOMEBREW_CELLAR}
 EOS
   fi
 
-  if [[ ! -w "$HOMEBREW_REPOSITORY" ]]
+  if [[ ! -w "${HOMEBREW_REPOSITORY}" ]]
   then
     odie <<EOS
-$HOMEBREW_REPOSITORY is not writable. You should change the
-ownership and permissions of $HOMEBREW_REPOSITORY back to your
+${HOMEBREW_REPOSITORY} is not writable. You should change the
+ownership and permissions of ${HOMEBREW_REPOSITORY} back to your
 user account:
-  sudo chown -R \$(whoami) $HOMEBREW_REPOSITORY
+  sudo chown -R \$(whoami) ${HOMEBREW_REPOSITORY}
 EOS
   fi
 
   # we may want to use a Homebrew curl
-  if [[ -n "$HOMEBREW_FORCE_BREWED_CURL" &&
-      ! -x "$HOMEBREW_PREFIX/opt/curl/bin/curl" ]]
+  if [[ -n "${HOMEBREW_FORCE_BREWED_CURL}" &&
+      ! -x "${HOMEBREW_PREFIX}/opt/curl/bin/curl" ]]
   then
     # we cannot install a Homebrew cURL if homebrew/core is unavailable.
-    if [[ ! -d "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" ]] || ! brew install curl
+    if [[ ! -d "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" ]] || ! brew install curl
     then
       odie "'curl' must be installed and in your PATH!"
     fi
   fi
 
   if ! git --version &>/dev/null ||
-     [[ -n "$HOMEBREW_FORCE_BREWED_GIT" &&
-      ! -x "$HOMEBREW_PREFIX/opt/git/bin/git" ]]
+     [[ -n "${HOMEBREW_FORCE_BREWED_GIT}" &&
+      ! -x "${HOMEBREW_PREFIX}/opt/git/bin/git" ]]
   then
     # we cannot install a Homebrew Git if homebrew/core is unavailable.
-    if [[ ! -d "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" ]] || ! brew install git
+    if [[ ! -d "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" ]] || ! brew install git
     then
       odie "'git' must be installed and in your PATH!"
     fi
   fi
 
-  [[ -f "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core/.git/shallow" ]] && HOMEBREW_CORE_SHALLOW=1
-  [[ -f "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-cask/.git/shallow" ]] && HOMEBREW_CASK_SHALLOW=1
-  if [[ -n $HOMEBREW_CORE_SHALLOW && -n $HOMEBREW_CASK_SHALLOW ]]
+  [[ -f "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core/.git/shallow" ]] && HOMEBREW_CORE_SHALLOW=1
+  [[ -f "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask/.git/shallow" ]] && HOMEBREW_CASK_SHALLOW=1
+  if [[ -n ${HOMEBREW_CORE_SHALLOW} && -n ${HOMEBREW_CASK_SHALLOW} ]]
   then
     SHALLOW_COMMAND_PHRASE="These commands"
     SHALLOW_REPO_PHRASE="repositories"
@@ -396,15 +403,15 @@ EOS
     SHALLOW_REPO_PHRASE="repository"
   fi
 
-  if [[ -n $HOMEBREW_CORE_SHALLOW || -n $HOMEBREW_CASK_SHALLOW ]]
+  if [[ -n ${HOMEBREW_CORE_SHALLOW} || -n ${HOMEBREW_CASK_SHALLOW} ]]
   then
     odie <<EOS
 ${HOMEBREW_CORE_SHALLOW:+
   homebrew-core is a shallow clone.}${HOMEBREW_CASK_SHALLOW:+
   homebrew-cask is a shallow clone.}
 To \`brew update\`, first run:${HOMEBREW_CORE_SHALLOW:+
-  git -C "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" fetch --unshallow}${HOMEBREW_CASK_SHALLOW:+
-  git -C "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-cask" fetch --unshallow}
+  git -C "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" fetch --unshallow}${HOMEBREW_CASK_SHALLOW:+
+  git -C "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask" fetch --unshallow}
 ${SHALLOW_COMMAND_PHRASE} may take a few minutes to run due to the large size of the ${SHALLOW_REPO_PHRASE}.
 This restriction has been made on GitHub's request because updating shallow
 clones is an extremely expensive operation due to the tree layout and traffic of
@@ -418,26 +425,26 @@ EOS
   export GIT_TERMINAL_PROMPT="0"
   export GIT_SSH_COMMAND="ssh -oBatchMode=yes"
 
-  if [[ -n "$HOMEBREW_GIT_NAME" ]]
+  if [[ -n "${HOMEBREW_GIT_NAME}" ]]
   then
-    export GIT_AUTHOR_NAME="$HOMEBREW_GIT_NAME"
-    export GIT_COMMITTER_NAME="$HOMEBREW_GIT_NAME"
+    export GIT_AUTHOR_NAME="${HOMEBREW_GIT_NAME}"
+    export GIT_COMMITTER_NAME="${HOMEBREW_GIT_NAME}"
   fi
 
-  if [[ -n "$HOMEBREW_GIT_EMAIL" ]]
+  if [[ -n "${HOMEBREW_GIT_EMAIL}" ]]
   then
-    export GIT_AUTHOR_EMAIL="$HOMEBREW_GIT_EMAIL"
-    export GIT_COMMITTER_EMAIL="$HOMEBREW_GIT_EMAIL"
+    export GIT_AUTHOR_EMAIL="${HOMEBREW_GIT_EMAIL}"
+    export GIT_COMMITTER_EMAIL="${HOMEBREW_GIT_EMAIL}"
   fi
 
-  if [[ -z "$HOMEBREW_VERBOSE" ]]
+  if [[ -z "${HOMEBREW_VERBOSE}" ]]
   then
     QUIET_ARGS=(-q)
   else
     QUIET_ARGS=()
   fi
 
-  if [[ -z "$HOMEBREW_CURLRC" ]]
+  if [[ -z "${HOMEBREW_CURLRC}" ]]
   then
     CURL_DISABLE_CURLRC_ARGS=(-q)
   else
@@ -449,69 +456,69 @@ EOS
 
   git_init_if_necessary
 
-  if [[ "$HOMEBREW_BREW_DEFAULT_GIT_REMOTE" != "$HOMEBREW_BREW_GIT_REMOTE" ]]
+  if [[ "${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_BREW_GIT_REMOTE}" ]]
   then
-    safe_cd "$HOMEBREW_REPOSITORY"
-    echo "HOMEBREW_BREW_GIT_REMOTE set: using $HOMEBREW_BREW_GIT_REMOTE for Homebrew/brew Git remote."
-    git remote set-url origin "$HOMEBREW_BREW_GIT_REMOTE"
+    safe_cd "${HOMEBREW_REPOSITORY}"
+    echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} for Homebrew/brew Git remote."
+    git remote set-url origin "${HOMEBREW_BREW_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force --tags origin
   fi
 
-  if [[ "$HOMEBREW_CORE_DEFAULT_GIT_REMOTE" != "$HOMEBREW_CORE_GIT_REMOTE" ]] &&
-     [[ -d "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" ]]
+  if [[ "${HOMEBREW_CORE_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_CORE_GIT_REMOTE}" ]] &&
+     [[ -d "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" ]]
   then
-    safe_cd "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core"
-    echo "HOMEBREW_CORE_GIT_REMOTE set: using $HOMEBREW_CORE_GIT_REMOTE for Homebrew/brew Git remote."
-    git remote set-url origin "$HOMEBREW_CORE_GIT_REMOTE"
+    safe_cd "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core"
+    echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} for Homebrew/brew Git remote."
+    git remote set-url origin "${HOMEBREW_CORE_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force origin refs/heads/master:refs/remotes/origin/master
   fi
 
-  safe_cd "$HOMEBREW_REPOSITORY"
+  safe_cd "${HOMEBREW_REPOSITORY}"
 
   # if an older system had a newer curl installed, change each repo's remote URL from GIT to HTTPS
-  if [[ -n "$HOMEBREW_SYSTEM_CURL_TOO_OLD" &&
-        -x "$HOMEBREW_PREFIX/opt/curl/bin/curl" &&
+  if [[ -n "${HOMEBREW_SYSTEM_CURL_TOO_OLD}" &&
+        -x "${HOMEBREW_PREFIX}/opt/curl/bin/curl" &&
         "$(git config remote.origin.url)" =~ ^git:// ]]
   then
-    git config remote.origin.url "$HOMEBREW_BREW_GIT_REMOTE"
-    git config -f "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core/.git/config" remote.origin.url "$HOMEBREW_CORE_GIT_REMOTE"
+    git config remote.origin.url "${HOMEBREW_BREW_GIT_REMOTE}"
+    git config -f "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core/.git/config" remote.origin.url "${HOMEBREW_CORE_GIT_REMOTE}"
   fi
 
   # kill all of subprocess on interrupt
   trap '{ /usr/bin/pkill -P $$; wait; exit 130; }' SIGINT
 
-  local update_failed_file="$HOMEBREW_REPOSITORY/.git/UPDATE_FAILED"
-  local missing_remote_ref_dirs_file="$HOMEBREW_REPOSITORY/.git/FAILED_FETCH_DIRS"
-  rm -f "$update_failed_file"
-  rm -f "$missing_remote_ref_dirs_file"
+  local update_failed_file="${HOMEBREW_REPOSITORY}/.git/UPDATE_FAILED"
+  local missing_remote_ref_dirs_file="${HOMEBREW_REPOSITORY}/.git/FAILED_FETCH_DIRS"
+  rm -f "${update_failed_file}"
+  rm -f "${missing_remote_ref_dirs_file}"
 
-  for DIR in "$HOMEBREW_REPOSITORY" "$HOMEBREW_LIBRARY"/Taps/*/*
+  for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/*
   do
-    [[ -d "$DIR/.git" ]] || continue
-    cd "$DIR" || continue
+    [[ -d "${DIR}/.git" ]] || continue
+    cd "${DIR}" || continue
 
-    if [[ -n "$HOMEBREW_VERBOSE" ]]
+    if [[ -n "${HOMEBREW_VERBOSE}" ]]
     then
-      echo "Checking if we need to fetch $DIR..."
+      echo "Checking if we need to fetch ${DIR}..."
     fi
 
-    TAP_VAR="$(repo_var "$DIR")"
+    TAP_VAR="$(repo_var "${DIR}")"
     UPSTREAM_BRANCH_DIR="$(upstream_branch)"
-    declare UPSTREAM_BRANCH"$TAP_VAR"="$UPSTREAM_BRANCH_DIR"
-    declare PREFETCH_REVISION"$TAP_VAR"="$(git rev-parse -q --verify refs/remotes/origin/"$UPSTREAM_BRANCH_DIR")"
+    declare UPSTREAM_BRANCH"${TAP_VAR}"="${UPSTREAM_BRANCH_DIR}"
+    declare PREFETCH_REVISION"${TAP_VAR}"="$(git rev-parse -q --verify refs/remotes/origin/"${UPSTREAM_BRANCH_DIR}")"
 
     # Force a full update if we don't have any tags.
-    if [[ "$DIR" = "$HOMEBREW_REPOSITORY" && -z "$(git tag --list)" ]]
+    if [[ "${DIR}" = "${HOMEBREW_REPOSITORY}" && -z "$(git tag --list)" ]]
     then
       HOMEBREW_UPDATE_FORCE=1
     fi
 
-    if [[ -z "$HOMEBREW_UPDATE_FORCE" ]]
+    if [[ -z "${HOMEBREW_UPDATE_FORCE}" ]]
     then
-      [[ -n "$SKIP_FETCH_BREW_REPOSITORY" && "$DIR" = "$HOMEBREW_REPOSITORY" ]] && continue
-      [[ -n "$SKIP_FETCH_CORE_REPOSITORY" && "$DIR" = "$HOMEBREW_LIBRARY/Taps/homebrew/homebrew-core" ]] && continue
+      [[ -n "${SKIP_FETCH_BREW_REPOSITORY}" && "${DIR}" = "${HOMEBREW_REPOSITORY}" ]] && continue
+      [[ -n "${SKIP_FETCH_CORE_REPOSITORY}" && "${DIR}" = "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" ]] && continue
     fi
 
     # The upstream repository's default branch may not be master;
@@ -523,12 +530,12 @@ EOS
 
       # HOMEBREW_UPDATE_FORCE and HOMEBREW_UPDATE_PREINSTALL aren't modified here so ignore subshell warning.
       # shellcheck disable=SC2030
-      if [[ "$UPSTREAM_REPOSITORY_URL" = "https://github.com/"* ]]
+      if [[ "${UPSTREAM_REPOSITORY_URL}" = "https://github.com/"* ]]
       then
         UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY_URL#https://github.com/}"
         UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY%.git}"
 
-        if [[ "$DIR" = "$HOMEBREW_REPOSITORY" && -n "$HOMEBREW_UPDATE_TO_TAG" ]]
+        if [[ "${DIR}" = "${HOMEBREW_REPOSITORY}" && -n "${HOMEBREW_UPDATE_TO_TAG}" ]]
         then
           # Only try to `git fetch` when the upstream tags have changed
           # (so the API does not return 304: unmodified).
@@ -538,30 +545,30 @@ EOS
         else
           # Only try to `git fetch` when the upstream branch is at a different SHA
           # (so the API does not return 304: unmodified).
-          GITHUB_API_ETAG="$(git rev-parse "refs/remotes/origin/$UPSTREAM_BRANCH_DIR")"
+          GITHUB_API_ETAG="$(git rev-parse "refs/remotes/origin/${UPSTREAM_BRANCH_DIR}")"
           GITHUB_API_ACCEPT="application/vnd.github.v3.sha"
-          GITHUB_API_ENDPOINT="commits/$UPSTREAM_BRANCH_DIR"
+          GITHUB_API_ENDPOINT="commits/${UPSTREAM_BRANCH_DIR}"
         fi
 
         # HOMEBREW_CURL is set by brew.sh (and isn't mispelt here)
         # shellcheck disable=SC2153
-        UPSTREAM_SHA_HTTP_CODE="$("$HOMEBREW_CURL" \
+        UPSTREAM_SHA_HTTP_CODE="$("${HOMEBREW_CURL}" \
            "${CURL_DISABLE_CURLRC_ARGS[@]}" \
            --silent --max-time 3 \
            --location --no-remote-time --output /dev/null --write-out "%{http_code}" \
-           --dump-header "$DIR/.git/GITHUB_HEADERS" \
-           --user-agent "$HOMEBREW_USER_AGENT_CURL" \
-           --header "Accept: $GITHUB_API_ACCEPT" \
-           --header "If-None-Match: \"$GITHUB_API_ETAG\"" \
-           "https://api.github.com/repos/$UPSTREAM_REPOSITORY/$GITHUB_API_ENDPOINT")"
+           --dump-header "${DIR}/.git/GITHUB_HEADERS" \
+           --user-agent "${HOMEBREW_USER_AGENT_CURL}" \
+           --header "Accept: ${GITHUB_API_ACCEPT}" \
+           --header "If-None-Match: \"${GITHUB_API_ETAG}\"" \
+           "https://api.github.com/repos/${UPSTREAM_REPOSITORY}/${GITHUB_API_ENDPOINT}")"
 
         # Touch FETCH_HEAD to confirm we've checked for an update.
-        [[ -f "$DIR/.git/FETCH_HEAD" ]] && touch "$DIR/.git/FETCH_HEAD"
-        [[ -z "$HOMEBREW_UPDATE_FORCE" ]] && [[ "$UPSTREAM_SHA_HTTP_CODE" = "304" ]] && exit
-      elif [[ -n "$HOMEBREW_UPDATE_PREINSTALL" ]]
+        [[ -f "${DIR}/.git/FETCH_HEAD" ]] && touch "${DIR}/.git/FETCH_HEAD"
+        [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] && [[ "${UPSTREAM_SHA_HTTP_CODE}" = "304" ]] && exit
+      elif [[ -n "${HOMEBREW_UPDATE_PREINSTALL}" ]]
       then
         FORCE_AUTO_UPDATE="$(git config homebrew.forceautoupdate 2>/dev/null || echo "false")"
-        if [[ "$FORCE_AUTO_UPDATE" != "true" ]]
+        if [[ "${FORCE_AUTO_UPDATE}" != "true" ]]
         then
           # Don't try to do a `git fetch` that may take longer than expected.
           exit
@@ -571,110 +578,110 @@ EOS
 
       # HOMEBREW_VERBOSE isn't modified here so ignore subshell warning.
       # shellcheck disable=SC2030
-      if [[ -n "$HOMEBREW_VERBOSE" ]]
+      if [[ -n "${HOMEBREW_VERBOSE}" ]]
       then
-        echo "Fetching $DIR..."
+        echo "Fetching ${DIR}..."
       fi
 
-      local tmp_failure_file="$HOMEBREW_REPOSITORY/.git/TMP_FETCH_FAILURES"
-      rm -f "$tmp_failure_file"
+      local tmp_failure_file="${HOMEBREW_REPOSITORY}/.git/TMP_FETCH_FAILURES"
+      rm -f "${tmp_failure_file}"
 
-      if [[ -n "$HOMEBREW_UPDATE_PREINSTALL" ]]
+      if [[ -n "${HOMEBREW_UPDATE_PREINSTALL}" ]]
       then
         git fetch --tags --force "${QUIET_ARGS[@]}" origin \
-          "refs/heads/$UPSTREAM_BRANCH_DIR:refs/remotes/origin/$UPSTREAM_BRANCH_DIR" 2>/dev/null
+          "refs/heads/${UPSTREAM_BRANCH_DIR}:refs/remotes/origin/${UPSTREAM_BRANCH_DIR}" 2>/dev/null
       else
         # Capture stderr to tmp_failure_file
         if ! git fetch --tags --force "${QUIET_ARGS[@]}" origin \
-          "refs/heads/$UPSTREAM_BRANCH_DIR:refs/remotes/origin/$UPSTREAM_BRANCH_DIR" 2>>"$tmp_failure_file"
+          "refs/heads/${UPSTREAM_BRANCH_DIR}:refs/remotes/origin/${UPSTREAM_BRANCH_DIR}" 2>>"${tmp_failure_file}"
         then
           # Reprint fetch errors to stderr
-          [[ -f "$tmp_failure_file" ]] && cat "$tmp_failure_file" 1>&2
+          [[ -f "${tmp_failure_file}" ]] && cat "${tmp_failure_file}" 1>&2
 
-          if [[ "$UPSTREAM_SHA_HTTP_CODE" = "404" ]]
+          if [[ "${UPSTREAM_SHA_HTTP_CODE}" = "404" ]]
           then
-            TAP="${DIR#$HOMEBREW_LIBRARY/Taps/}"
-            echo "$TAP does not exist! Run \`brew untap $TAP\` to remove it." >>"$update_failed_file"
+            TAP="${DIR#${HOMEBREW_LIBRARY}/Taps/}"
+            echo "${TAP} does not exist! Run \`brew untap ${TAP}\` to remove it." >>"${update_failed_file}"
           else
-            echo "Fetching $DIR failed!" >>"$update_failed_file"
+            echo "Fetching ${DIR} failed!" >>"${update_failed_file}"
 
-            if [[ -f "$tmp_failure_file" ]] &&
-               [[ "$(<"$tmp_failure_file")" = "fatal: couldn't find remote ref refs/heads/$UPSTREAM_BRANCH_DIR" ]]
+            if [[ -f "${tmp_failure_file}" ]] &&
+               [[ "$(<"${tmp_failure_file}")" = "fatal: couldn't find remote ref refs/heads/${UPSTREAM_BRANCH_DIR}" ]]
             then
-              echo "$DIR" >>"$missing_remote_ref_dirs_file"
+              echo "${DIR}" >>"${missing_remote_ref_dirs_file}"
             fi
           fi
         fi
       fi
 
-      rm -f "$tmp_failure_file"
+      rm -f "${tmp_failure_file}"
     ) &
   done
 
   wait
   trap - SIGINT
 
-  if [[ -f "$update_failed_file" ]]
+  if [[ -f "${update_failed_file}" ]]
   then
-    onoe <"$update_failed_file"
-    rm -f "$update_failed_file"
+    onoe <"${update_failed_file}"
+    rm -f "${update_failed_file}"
     export HOMEBREW_UPDATE_FAILED="1"
   fi
 
-  if [[ -f "$missing_remote_ref_dirs_file" ]]
+  if [[ -f "${missing_remote_ref_dirs_file}" ]]
   then
-    HOMEBREW_MISSING_REMOTE_REF_DIRS="$(<"$missing_remote_ref_dirs_file")"
-    rm -f "$missing_remote_ref_dirs_file"
+    HOMEBREW_MISSING_REMOTE_REF_DIRS="$(<"${missing_remote_ref_dirs_file}")"
+    rm -f "${missing_remote_ref_dirs_file}"
     export HOMEBREW_MISSING_REMOTE_REF_DIRS
   fi
 
-  for DIR in "$HOMEBREW_REPOSITORY" "$HOMEBREW_LIBRARY"/Taps/*/*
+  for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/*
   do
-    [[ -d "$DIR/.git" ]] || continue
-    cd "$DIR" || continue
+    [[ -d "${DIR}/.git" ]] || continue
+    cd "${DIR}" || continue
 
-    TAP_VAR="$(repo_var "$DIR")"
-    UPSTREAM_BRANCH_VAR="UPSTREAM_BRANCH$TAP_VAR"
+    TAP_VAR="$(repo_var "${DIR}")"
+    UPSTREAM_BRANCH_VAR="UPSTREAM_BRANCH${TAP_VAR}"
     UPSTREAM_BRANCH="${!UPSTREAM_BRANCH_VAR}"
     CURRENT_REVISION="$(read_current_revision)"
 
-    PREFETCH_REVISION_VAR="PREFETCH_REVISION$TAP_VAR"
+    PREFETCH_REVISION_VAR="PREFETCH_REVISION${TAP_VAR}"
     PREFETCH_REVISION="${!PREFETCH_REVISION_VAR}"
-    POSTFETCH_REVISION="$(git rev-parse -q --verify refs/remotes/origin/"$UPSTREAM_BRANCH")"
+    POSTFETCH_REVISION="$(git rev-parse -q --verify refs/remotes/origin/"${UPSTREAM_BRANCH}")"
 
     # HOMEBREW_UPDATE_FORCE and HOMEBREW_VERBOSE weren't modified in subshell.
     # shellcheck disable=SC2031
-    if [[ -n "$HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH" ]]
+    if [[ -n "${HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH}" ]]
     then
-      simulate_from_current_branch "$DIR" "$TAP_VAR" "$UPSTREAM_BRANCH" "$CURRENT_REVISION"
-    elif [[ -z "$HOMEBREW_UPDATE_FORCE" ]] &&
-         [[ "$PREFETCH_REVISION" = "$POSTFETCH_REVISION" ]] &&
-         [[ "$CURRENT_REVISION" = "$POSTFETCH_REVISION" ]]
+      simulate_from_current_branch "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}" "${CURRENT_REVISION}"
+    elif [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] &&
+         [[ "${PREFETCH_REVISION}" = "${POSTFETCH_REVISION}" ]] &&
+         [[ "${CURRENT_REVISION}" = "${POSTFETCH_REVISION}" ]]
     then
-      export HOMEBREW_UPDATE_BEFORE"$TAP_VAR"="$CURRENT_REVISION"
-      export HOMEBREW_UPDATE_AFTER"$TAP_VAR"="$CURRENT_REVISION"
+      export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${CURRENT_REVISION}"
+      export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}"
     else
-      merge_or_rebase "$DIR" "$TAP_VAR" "$UPSTREAM_BRANCH"
-      [[ -n "$HOMEBREW_VERBOSE" ]] && echo
+      merge_or_rebase "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}"
+      [[ -n "${HOMEBREW_VERBOSE}" ]] && echo
     fi
   done
 
-  safe_cd "$HOMEBREW_REPOSITORY"
+  safe_cd "${HOMEBREW_REPOSITORY}"
 
   # HOMEBREW_UPDATE_PREINSTALL wasn't modified in subshell.
   # shellcheck disable=SC2031
-  if [[ -n "$HOMEBREW_UPDATED" ||
-        -n "$HOMEBREW_UPDATE_FAILED" ||
-        -n "$HOMEBREW_FAILED_FETCH_DIRS" ||
-        -n "$HOMEBREW_UPDATE_FORCE" ||
-        -d "$HOMEBREW_LIBRARY/LinkedKegs" ||
-        ! -f "$HOMEBREW_CACHE/all_commands_list.txt" ||
-        (-n "$HOMEBREW_DEVELOPER" && -z "$HOMEBREW_UPDATE_PREINSTALL") ]]
+  if [[ -n "${HOMEBREW_UPDATED}" ||
+        -n "${HOMEBREW_UPDATE_FAILED}" ||
+        -n "${HOMEBREW_MISSING_REMOTE_REF_DIRS}" ||
+        -n "${HOMEBREW_UPDATE_FORCE}" ||
+        -d "${HOMEBREW_LIBRARY}/LinkedKegs" ||
+        ! -f "${HOMEBREW_CACHE}/all_commands_list.txt" ||
+        (-n "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_UPDATE_PREINSTALL}") ]]
   then
     brew update-report "$@"
     return $?
-  elif [[ -z "$HOMEBREW_UPDATE_PREINSTALL" &&
-          -z "$HOMEBREW_QUIET" ]]
+  elif [[ -z "${HOMEBREW_UPDATE_PREINSTALL}" &&
+          -z "${HOMEBREW_QUIET}" ]]
   then
     echo "Already up-to-date."
   fi