<?xml version="1.0" encoding="UTF-8"?>
<PackageSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0  http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">
  <SpdHeader>
    <PackageName>EdkShellBinPkg</PackageName>
    <Guid>d4266a1b-1d38-4116-93ae-60dc3e2012a6</Guid>
    <Version>0.3</Version>
    <Abstract>Reference package showing multiple binaries</Abstract>
    <Description>This package contains multiple binary drivers, using only one MSA, one MBD and a single SPD.</Description>
    <Copyright>Copyright (c) 2006,  Intel Corporation.</Copyright>
    <License>
      All rights reserved.
      This program and the accompanying materials are licensed and made available 
      under the terms and conditions of the BSD License which accompanies this distribution.
      The full text of the license may be found at http://opensource.org/licenses/bsd-license.php
      THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES
      OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
    </License>
    <ReadOnly>true</ReadOnly>
    <RePackage>false</RePackage>
    <Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION     0x00000052</Specification>
  </SpdHeader>
  <MsaFiles>
    <MsaFile>
      <Filename>bin/Shell.msa</Filename>
    </MsaFile>
  </MsaFiles>
</PackageSurfaceArea>
