anchor.diff:    sdk: 2.x
   ```
   
  -The buildpack chooses which SDK to install based on the files present at the app root using the following order of precedence:
  +The buildpack chooses which SDK to install based on the files present at the app root, according to the following order of precedence:
   
   1. `buildpack.yml`
   1. `global.json`
  -1. `*.fsproj`
  -
  -<p class="note"><strong>Note</strong>: The app respects the SDK version specified in <code>global.json</code> at runtime.
  -If you provide versions in both <code>global.json</code> and <code>buildpack.yml</code> files,
  -ensure that you specify the same versions in both files.</p>
  -
  -## <a id='dotnet-runtime'></a>Specify .NET Runtime Versions
  -
  -### <a id='dotnet-runtime-source-based'></a>Source-Based Apps
  -
  -For source-based apps, specify a minor version of the .NET Runtime.
  -Do not specify a patch version because
  +1. If the app contains only `*.fsproj` files, the buildpack installs the latest 1.1.x SDK.
  +
  +<p class="note"><strong>Note</strong>: The app respects the SDK version specified in <code>global.json</code> at runtime. If you provide versions in both <code>global.json</code> and <code>buildpack.yml</code> files, ensure that you specify the same versions in both files.</p>
  +
  +## <a id='dotnet-runtime'></a>Specifying .NET Runtime Versions
  +### <a id='dotnet-runtime-source-based'></a>For source-based apps
  +
  +Specify a minor version of the .NET Runtime.
  +Do not specify a patch version, because
   buildpacks contain only the two most recent patch versions of each minor version.
   
  -To lock the .NET Runtime version, add the following to your `.csproj` or `.fsproj` file :
  +Add the following to your `.csproj` or `.fsproj` file to lock the .NET Runtime version:
   
   ```
   <PropertyGroup>
  
positive.code: 
      This allows the buildpack to pass the correct port from `$PORT` to the app when running the initial startup command.
  
  1. Add `Microsoft.Extensions.Configuration.CommandLine` as a dependency in `*.csproj`:
  
      ```
      <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine">
          <Version>VERSION</Version>
      </PackageReference>
      ```
  
      In the above example, replace `VERSION` with the version of the package to use. You can find valid versions at https://www.nuget.org.
  
  1. If your app requires any other files at runtime, such as JSON configuration files, add them to the `include` section of `copyToOutput`.
  
  1. Save your changes.
  
  With these changes, the `dotnet run` command copies your app `Views` to the build output where the .NET CLI can find them.
  Refer to the following example `Main` method:
  
  ```c#
  public static void Main(string[] args)
  
negative.code: 
      <pre class="terminal">$ cf set-env YOUR-APP CACHE_NUGET_PACKAGES false</pre>
  
  See the [Environment Variables](../../devguide/deploy-apps/manifest.html#env-block) section of the <em>Deploying with Application Manifests</em> topic for more information.
  
  
  ## <a id='framework-dependent'></a>Framework Dependent Deployments (FDD) Workflow ##
  This is the recommended workflow when deploying an app in an offline setting.
  
  To deploy an [FDD](https://docs.microsoft.com/en-us/dotnet/core/deploying/index#framework-dependent-deployments-fdd) using the buildpack:
  
  
  1. Publish the app by running `dotnet publish [-f <framework>] [-c Release]`.
  
  1. Navigate to the `bin/<Debug|Release>/<framework>/<runtime>/publish` directory. Or, if your app uses a `manifest.yml`, specify a path to the publish output folder. This allows you to push your app from any directory.
  
  1. Push your app.
  
  **Note**: Unless you want to pin your .NET Framework to a specific version (see below), do not set `applyPatches: false` in  `*.runtimeconfig.json`, as this will prevent your app from receiving updates to the runtime version and assemblies.
  
  
  ## <a id='self-contained'></a>Self-Contained Deployments (SCD) Workflow ##
  This workflow is not recommended. Because this workflow results in a prepublished binary, we are unable to keep all your dependencies in-sync and up-to-date.
  
  The SCD workflow is the same as the FDD workflow, except you must specify a runtime in the publish command:
  
  ```
  dotnet publish -r ubuntu14.04-x64
  ```
  
  The specified runtime should also be included in the `RuntimeIdentifiers` section of the project file.
  
  See [more details for FDD vs SCD deployments](https://docs.microsoft.com/en-us/dotnet/core/deploying/)
  
  
  ## <a id='dotnet-sdk'></a> Specifying .NET Core SDKs
  To pin the .NET Core SDK to a specific version or version line, create a `buildpack.yml` file at the app root and add the following:
  
  ```
  dotnet-core:
    sdk: 2.1.201
  ```
  
  The following formats are also valid:
  
  ```
  dotnet-core:
    sdk: 2.1.x
  