anchor.diff:  
       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`:
   
  -        ```xml
  -        <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine">
  -            <Version>VERSION</Version>
  -        </PackageReference>
  -        ```
  -
  -    In the above examples, replace `VERSION` with the version of the package to use. Valid versions can be found at https://www.nuget.org.
  +    ```
  +    <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:
  +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)
  
positive.code: </PropertyGroup>
  ```
  
  This is results in a fully vendored app but will require fewer buildpack updates.
  
  If you do not want to use this option you can set `buildpack.yml` to your desired .NET SDK line to keep the SDK up to date:
  
  ```
  
  ---
  dotnet-core:
  	sdk: 2.0.x
  ```
  
  **Note:** Dotnet releases `2.0.x` AspNetCore assemblies in the `2.1.200`-`2.1.299` SDK versions. `2.1.x` assemblies are released in the `2.1.300` and above SDK versions.
  
  ## <a id='port'></a>Configure the Listen Port ##
  
  For your .NET Core app to work on <%= vars.product_windows %>, you must modify the `Main` method to configure the app to listen on the port specified by the `$PORT` environment variable. <%= vars.product_windows %> sets this environment variable automatically.
  
  1. Open the file that contains your `Main` method.
  
  
negative.code:     $ cf push MY-APP -b https://github.com/cloudfoundry/dotnet-core-buildpack.git
      </pre>
  
  1. Find the URL of your app in the output from the push command and navigate to it to see your app running.  In the example above, `my-app.example.com` is the URL of your app.
  
  For a basic example app, see [ASP.NET Core getting started application](https://github.com/IBM-Bluemix/aspnet-core-helloworld) in GitHub.
  
  ## <a id='source-based'></a>Source-Based, Non-Published Deployments
  
  To use this workflow, push the source code for your app, not the output directory of the `dotnet publish` command,
  to Cloud Foundry by running the `cf push` command.
  
  The source-based, non-published workflow ensures the buildpack can keep all your dependencies in sync and up to date.
  For additional information about using this workflow, see the following sections:
  
  * [Deploy Apps with Multiple Projects](#multiple-projects)
  * [Use Non-Default Package Sources](#non-default-package-sources)
  * [Disable and Clear the NuGet Package Cache](#disabling-nuget)
  
  ### <a id='multiple-projects'></a>Deploy Apps with Multiple Projects
  
  If you want to deploy an app that contains multiple projects, you must specify your main project for the buildpack to run.
  Create a `.deployment` file in the root folder of the app that sets the path to the main project as follows:
  
  ```text
  [config]
  project = PATH-TO-YOUR-MAIN-PROJECT
  ```
  
  Where `PATH-TO-YOUR-MAIN-PROJECT` is the location of your main project.
  Set `project` to the `*.csproj` or `*.fsproj` file of the main project.
  
  For example, if an app contains three projects in the `src` folder,
  the main project `MyApp.Web` as well as `MyApp.DAL` and `MyApp.Services`,
  format the `.deployment` file as follows:
  
  ```text
  [config]
  project = src/MyApp.Web/MyApp.Web.csproj
  ```
  
  In this example, the buildpack automatically compiles the `MyApp.DAL` and `MyApp.Services` projects
  if the `MyApp.Web.csproj` file of the main project lists them as dependencies.
  The buildpack attempts to execute the main project with `dotnet run -p src/MyApp.Web/MyApp.Web.csproj`.
  
  ### <a id='non-default-package-sources'></a>Use Non-Default Package Sources
  
  If you want to deploy an app that uses non-default package sources,
  you must specify those package sources in the `NuGet.Config` file.
  For information about `NuGet.Config`,
  see [nuget.config reference](https://docs.microsoft.com/en-us/nuget/reference/nuget-config-file)
  in the Microsoft documentation.
  For a basic example of a .NET Core app,
  see the [aspnet-core-helloworld](https://github.com/IBM-Bluemix/aspnet-core-helloworld) repository on GitHub.
  
  ### <a id='disabling-nuget'></a>Disable and Clear the NuGet Package Cache
  
  You may need to disable NuGet package caching or clear NuGet packages cached in the staging environment
  in one of the following scenarios:
  
  * Your app fails to stage because it runs out of space, exceeding the maximum allowable disk quota.
  * You have added pre-release packages to test a new feature, and then decided to revert back to the main NuGet feed.
  You may need to remove the packages you changed from the cache to avoid conflicts.
  
  Disabling NuGet caching clears any existing NuGet dependencies from the staging cache
  and prevents the buildpack from adding NuGet dependencies to the staging cache.
  To disable NuGet package caching, set the `CACHE_NUGET_PACKAGES` environment variable to `false`.
  If the variable is not set, no change is required.
  
  To set `CACHE_NUGET_PACKAGES` to `false`, perform one of the following:
  
  * Locate your app manifest, `manifest.yml`, and set the `CACHE_NUGET_PACKAGES` environment variable to `false`:
  
      ```yml
      ---
  