hunk.code_window:   // Package
     shell.sed('-i', `applicationId 'host.exp.exponent'`, `applicationId '${javaPackage}'`, `${shellPath}app/build.gradle`);
     await sedInPlaceAsync('-e', `s/android:name="host.exp.exponent"/android:name="${javaPackage}"/g`, `${shellPath}app/src/main/AndroidManifest.xml`);
     // Remove Exponent build script
     shell.sed('-i', `preBuild.dependsOn generateDynamicMacros`, ``, `${shellPath}app/build.gradle`);
     // change javaMaxHeapSize
     shell.sed('-i', `javaMaxHeapSize "8g"`, `javaMaxHeapSize "6g"`, `${shellPath}app/build.gradle`);
  
hunk.labels: keep keep keep keep add keep keep keep keep keep
hunk.after_edit:   // Versions
     let buildGradleFile = await fs.promise.readFile(`${shellPath}app/build.gradle`, 'utf8');
     let androidVersion = buildGradleFile.match(/versionName '(\S+)'/)[1];
     shell.sed('-i', 'VERSION_NAME = null', `VERSION_NAME = "${androidVersion}"`, `${shellPath}app/src/main/java/host/exp/exponent/Constants.java`);
     await sedInPlaceAsync('-e', `/BEGIN\ VERSIONS/,/END\ VERSIONS/d`, `${shellPath}app/build.gradle`);
     shell.sed('-i', '// ADD VERSIONS HERE', `versionCode ${versionCode}
       versionName '${version}'`, `${shellPath}app/build.gradle`);
  
hunk.file_path: tools-public/android-shell-app.js
hunk.type: add
file: /**
   * @generated SignedSource<<b68d78236d45828b3f7f7fcc740782a9>>
   *
   * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   * !! This file is a check-in of a static_upstream project!      !!
   * !!                                                            !!
   * !! You should not modify this file directly. Instead:         !!
   * !! 1) Use `fjs use-upstream` to temporarily replace this with !!
   * !!    the latest version from upstream.                       !!
   * !! 2) Make your changes, test them, etc.                      !!
   * !! 3) Use `fjs push-upstream` to copy your changes back to    !!
   * !!    static_upstream.                                        !!
   * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   *
   * Copyright 2013-2014 Facebook, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * @providesModule mergeHelpers
   *
   * requiresPolyfills: Array.isArray
   */
  
  "use strict";
  
  var invariant = require('fbjs/lib/invariant');
  var keyMirror = require('fbjs/lib/keyMirror');
  
  /**
   * Maximum number of levels to traverse. Will catch circular structures.
   * @const
   */
  var MAX_MERGE_DEPTH = 36;
  
  /**
   * We won't worry about edge cases like new String('x') or new Boolean(true).
   * Functions are considered terminals, and arrays are not.
   * @param {*} o The item/object/value to test.
   * @return {boolean} true iff the argument is a terminal.
   */
  var isTerminal = function(o) {
    return typeof o !== 'object' || o === null;
  };
  
  var mergeHelpers = {
  
    MAX_MERGE_DEPTH: MAX_MERGE_DEPTH,
  
    isTerminal: isTerminal,
  
    /**
     * Converts null/undefined values into empty object.
     *
     * @param {?Object=} arg Argument to be normalized (nullable optional)
     * @return {!Object}
     */
    normalizeMergeArg: function(arg) {
      return arg === undefined || arg === null ? {} : arg;
    },
  
    /**
     * If merging Arrays, a merge strategy *must* be supplied. If not, it is
     * likely the caller's fault. If this function is ever called with anything
     * but `one` and `two` being `Array`s, it is the fault of the merge utilities.
     *
     * @param {*} one Array to merge into.
     * @param {*} two Array to merge from.
     */
    checkMergeArrayArgs: function(one, two) {
      invariant(
        Array.isArray(one) && Array.isArray(two),
        'Tried to merge arrays, instead got %s and %s.',
        one,
        two
      );
    },
  
    /**
     * @param {*} one Object to merge into.
     * @param {*} two Object to merge from.
     */
    checkMergeObjectArgs: function(one, two) {
      mergeHelpers.checkMergeObjectArg(one);
      mergeHelpers.checkMergeObjectArg(two);
    },
  
    /**
     * @param {*} arg
     */
    checkMergeObjectArg: function(arg) {
      invariant(
        !isTerminal(arg) && !Array.isArray(arg),
        'Tried to merge an object, instead got %s.',
        arg
      );
    },
  
    /**
     * @param {*} arg
     */
    checkMergeIntoObjectArg: function(arg) {
      invariant(
        (!isTerminal(arg) || typeof arg === 'function') && !Array.isArray(arg),
        'Tried to merge into an object, instead got %s.',
        arg
      );
    },
  
    /**
     * Checks that a merge was not given a circular object or an object that had
     * too great of depth.
     *
     * @param {number} Level of recursion to validate against maximum.
     */
    checkMergeLevel: function(level) {
      invariant(
        level < MAX_MERGE_DEPTH,
        'Maximum deep merge depth exceeded. You may be attempting to merge ' +
        'circular structures in an unsupported way.'
      );
    },
  
    /**
     * Checks that the supplied merge strategy is valid.
     *
     * @param {string} Array merge strategy.
     */
    checkArrayStrategy: function(strategy) {
      invariant(
        strategy === undefined || strategy in mergeHelpers.ArrayStrategies,
        'You must provide an array strategy to deep merge functions to ' +
        'instruct the deep merge how to resolve merging two arrays.'
      );
    },
  
    /**
     * Set of possible behaviors of merge algorithms when encountering two Arrays
     * that must be merged together.
     * - `clobber`: The left `Array` is ignored.
     * - `indexByIndex`: The result is achieved by recursively deep merging at
     *   each index. (not yet supported.)
     */
    ArrayStrategies: keyMirror({
      Clobber: true,
      IndexByIndex: true
    })
  
  };
  
  module.exports = mergeHelpers;
  