lappend ::auto_path [file join $pkgr_path Eagle1.0]
    } else {
      lappend ::auto_path [file join [file dirname [file dirname \
          [file dirname $pkgr_path]]] externals Eagle lib Eagle1.0]
    }
  }

  variable pkgr_harpy_path; # DEFAULT: <unset>

  if {![info exists pkgr_harpy_path]} then {
    set pkgr_harpy_path [file normalize [file dirname [info script]]]

    if {![file isfile [file join $pkgr_harpy_path sign.eagle]]} then {
      set pkgr_harpy_path [file join [file dirname [file dirname \
          [file dirname $pkgr_harpy_path]]] externals Harpy Tools]
    }
  }

  #
  # NOTE: This package requires several packages from the Eagle core script
  #       library, even when it is being used by native Tcl.  If necessary,
  #       prior to evaluating this file in native Tcl, its auto-path should
  #       be modified to include an "Eagle1.0" directory (i.e. a directory
  #       containing the Eagle core script library files "auxiliary.eagle",
  #       "file1.eagle", and "platform.eagle").

      } else {
        error "cannot sign with OpenPGP: passphrase file does not exist"
      }
    } else {
      error "cannot sign with OpenPGP: passphrase file is not configured"
    }
  }

  #
  # NOTE: This procedure attempts to create a Harpy (script) certificate for
  #       the specified (named) file.  Non-zero is only returned if the Harpy
  #       (script) certificate is created successfully.  A script error should
  #       not be raised by this procedure.  The fileName argument must be the
  #       fully qualified path and file name of the file to be signed.  This
  #       procedure assumes that the Harpy package for Eagle is installed and
  #       ready for use (i.e. it can find a valid license certificate).
  #
  # <internal>
  proc createHarpyCertificate { fileName } {
    variable harpySignCommand
    variable pkgr_harpy_path

    set toolFileName \
        [file nativename [file join $pkgr_harpy_path sign.eagle]]

    set scriptFileName [file nativename $fileName]
    set vendor "Mistachkin Systems"; # NOTE: System default.

    if {[isEagle]} then {
      set shellFileName [formatExecArgument [info nameofexecutable]]
      set toolFileName [formatExecArgument $toolFileName]
      set scriptFileName [formatExecArgument $scriptFileName]
      set vendor [formatExecArgument $vendor]

      if {[catch {
        eval exec -success Success [subst $harpySignCommand]
      }] == 0} then {
        return true
      }
    } else {
      #
      # HACK: Make sure that Eagle is loaded into this process so that we
      #       can figure out the shell for it and then [exec] out to that
      #       shell.
      #
      makeEagleReady

      set shellFileName [eagle {
        file join [file dirname [lindex [info assembly] end]] EagleShell.exe
      }]

      if {[catch {
        eval exec [subst $harpySignCommand] 2>@1
      } result] == 0} then {
        return true
      }
    }

    return false
  }

  #
  # NOTE: This procedure attempts to create an OpenPGP signature for the
  #       specified (named) file.  Non-zero is only returned if the OpenPGP
  #       signature is created successfully.  A script error should not be
  #       raised by this procedure.  The fileName argument must be the fully
  #       qualified path and file name of the file to be signed.

  }

  #
  # NOTE: This procedure is designed for Eagle.  It attempts to load the
  #       "best" native Tcl library.  It may raise any number of script
  #       errors.  There are no arguments.
  #
  # <internal>
  proc makeTclReady {} {
    #
    # NOTE: This procedure is useless when running in native Tcl; therefore,
    #       forbid its use there.
    #
    if {![isEagle]} then {
      error "already running in Tcl language"

  }

  #
  # NOTE: This procedure, which may only be used from a native Tcl script,
  #       checks if Garuda and Eagle are loaded and ready.  If not, a script
  #       error is raised.  There are no arguments.
  #
  # <internal>
  proc eagleMustBeReady {} {
    #
    # NOTE: This procedure is useless when running in Eagle; therefore,
    #       forbid its use there.
    #
    if {[isEagle]} then {
      error "already running in Eagle language"

  }

  #
  # NOTE: This procedure is designed for native Tcl.  It attempts to load
  #       the Garuda package and gain access to Eagle.  It may raise any
  #       number of script errors.  There are no arguments.
  #
  # <internal>
  proc makeEagleReady {} {
    #
    # NOTE: This procedure is useless when running in Eagle; therefore,
    #       forbid its use there.
    #
    if {[isEagle]} then {
      error "already running in Eagle language"

      append openPgpSignCommand {gpg2 --detach-sign --armor}

      append openPgpSignCommand \
          { --passphrase-file [formatExecArgument [getOpenPgpPassphraseFile]]}

      append openPgpSignCommand { --batch --yes {${fileName}}}
    }

    #
    # NOTE: The command to use when creating Harpy signatures for downloaded
    #       package scripts.
    #
    variable harpySignCommand; # DEFAULT: {${shellFileName}} -file ...

    if {![info exists harpySignCommand]} then {
      set harpySignCommand ""

      append harpySignCommand {{${shellFileName}}}
      append harpySignCommand { -noArgumentsFileName -file {${toolFileName}}}
      append harpySignCommand { {${scriptFileName}} {${vendor}}}
    }

    #
    # NOTE: Verify that the package script matches the current language
    #       when called from the [package unknown] handler?
    #
    variable strictUnknownLanguage; # DEFAULT: true

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZbwvAAoJEFAslq9JXcLZAF8P/1LezognkKYq/qIZxqSa1O0q
Ng++zQUHb0ENQ9G0rdXL75ur8M3UQfpMsJk7e17/W9rGLiyq42UB5KezxwOkE6Bz
XIXhWc6pd+fIec7eVGsULyoYEgga3TCsCGhDkFnjxtBD1tCRDCmc72QX+KdkOjiF
Y/M4dvuITEWH4qc+oUVtczvUBevw9Icq3O7V3YGl0kvZK4hlsUAb9oeZm6qc5hM/
25AfOgEgHs+UERzIdNgz8nVBIykmRZHPmTyvJQuwP+0HtT+Snwi7pNVq5m0KprZB
xXkKcMQW03qcqqrlrrU6zvYptAUUrNOIpmi/2uOLpfqkZtK/SzP2EKpCRFyjnrVC
hdgTnM5XbgrxTkGQHxQm1zYNdqrO4wgSp7MjD18Ml/nKrRwACO8xc8/40GyU7+JZ
TvB/dslUhxM+jtsBMdu280hVqU15ucKfezB2Nj9JVzDb9FyG0UdrTwwuQv1PAkO3
c2+k3qaP3ZyMl3bh8fxnj8bE8Ux3dejCa5+JPB091+Z/mMqAXjrrGMDW75CzmTru
HcudRz/4FBCGihusfkf1uZ/iHCxp+YGtXIW+KrFcYHp5JEwEUk2dUf1PknFb4XhT
v82qcfVQt/EaphahnbUsUAJWAqBvYx4CVwN5IKv4K1Gwfyq4kFLA86D3DtMMjkQW
ivxnCrbG7w2B9l+oc0dW
=67id
-----END PGP SIGNATURE-----

    THE ASSOCIATED SOFTWARE MAY NOT WORK PROPERLY IF THIS FILE IS ALTERED.
-->
<Certificate xmlns="https://eagle.to/2011/harpy"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Protocol>None</Protocol>
  <Vendor>Mistachkin Systems</Vendor>
  <Id>d2d08422-cd9e-46f2-b95c-0437afc905fc</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-12-30T01:44:52.3986953Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    mpNlV2s/jRbLLdrTsHkpNbzSdTyRfanqn8YT9YMyK91I0R2Z/44ZyhULfmpdOr/9IFC3VAk3c9B9
    /zol8IzrO8ckZal+92IwaOYeP81Jjs1HnHh+x8VDJFgXGyLlLD573mGDjSwcL0LbMzs8W5yvZHIT
    3nmlxf5nf08Z5Y/JLzEBNaEJBEnA3vvj69EtjLr1GrVIX0WfBToykt+2bwmRRfb/QQFlGeCCzBSG
    HezgY2EfT3dK6uIO8iYxfh4io3IqkvQ9qYz5fx+1CvTRNHbIEOMox2J8nqCH4/txsITbVh38EbJp
    oYXW6wUL8ysdRlYbAwvxk3m/L1Ls0UJlG5IQuGnLHyNdGGcSXyQpyHaiuPLsHbL3K4lrRLFgRmZP
    uhmS4FWlaRYpt2L+xTllelagXQmPC4UqM6piL58IjkXMhwPGATxRKW3uJH+LYTcw/wkI/qcFZHxY
    tABUwIfbrWqaR/tXhW75IG6a6FKIAsUx0i/noDJ7RhD+iw+/1/PGb4mWXlQVHYymDia9ZFIndb0L
    vYKsLLQkTRB5T2b+x1Qg/Rsm6xXYP1nwX+oXppTvQp7b+gV9gGPMNNPL/AJ5dM3joPYk1Ri0QjRP
    Xx3RLNElVrzzWqcbq1pFq1lJhHZZYWBecYw9MIop3BBTW+EhzFSIbWaldBwoXQJZW5opo3S9rKAh
    lHw2x7hcT2hWKtajo6aLc8CNnAESa2743yIZcQx6CWClS5oN53I9GwItNfewFvRxDnWRHkTB04hl
    +oUVIq5H/T4f1JgVfI8ZZDEM37MQg3RgEIyg8dJXasfrcX1+DvWXIB7P9x3grCBZjuD2HCwxJVl6
    Oh6C2b0L2gUstB/0IPJTekTz7uXKFTBdwkXBCK1ZxV4xmY8l+P/7B7EZaG51jRoSyfB0CM3gs5fr
    eKe1eVDDjpp9p+bPSM26xZK5thfMQypne1yx4CCg5E/xrcFd/J+dsS7iQC93Q5ustymJ5477Y5V+
    HkeYHq28x1IgVeQ33PSDM2Te6VE/mIAdvWvffopJsKRCdz6IWj8YbkfpMCHAzZ20EWSjvadyLSyo
    vY9/m5vHbjpYpMEtOMb4sUaWpndibwP8aFRQwbDfSj7IeZqEJaz7sTveo6Wp0jvX+UCZgmtNjg64
    1JPQm8eaIS9NbQgfuguC8QxSjAjd77OqfLpr3l2w9pqFtdr7ReAiLgbqgezadORmbDP7Kb8EMmGG
    /k6+o1hJS4k+FIMECuclbAHPGYSIktpsTNJm6eUpurSXXoAqFZpHluH9vbtMWPkUpMRXh8fOQLrT
    nD1HJtGJ+FqyCOPvxAXYomus4lmwiBtkZpT1+twhkrDvSk+30N4PHGmm4ZCLRk50j6Er5Rho4N7X
    +MJQSO4zWAFYsweKP5BAk/gkgBXyOSYGkwmMo89sAxQjFLcV84758cGcgWd7BwIoNyuJKgJkEKgK
    NBxr5In18ozfFytQQmIUCCi69imESmeVX103RtpgUM0mWEHngHTbmsrq0A/Up3sHW7PiqTj8zs64
    pPykQ/W5sEZyG86kaIDiw4AxHx3XcGFCdYKGRXl3u64oJLRv1swW6JIJCICJJcG4IDuHlY/C5Q0w
    FDU9qjvbbR+2SsswwodtKSWGmp5a7tzWVZfGE9xjaFBKuaR6Dp32xWncBeoyIatzECTDi+K+xLAv
    hJbUCT/cgGNg98B/NXIOl6TZ4Db2xlW1e8G9qgEqFSU+aH21TKuGPGqsMFJgEYhM/vCQthoU+rdl
    UzWlYktWR/cujJFGRvt/soZUNVl0AmEMy0KnffNCSZtfHP1X7+xXv9A+Hl+u408HvdkKhtMFp8zh
    QNrT26mV5C27KWIL38p1a5nF8dP9Dm5H+AknuYjEO3NQXA6k8YSs6Zvzwv/k2hCYo+RE+L41eMaX
    JR3VIjgBEzwf/06m0I3YmBd8hg/unAOPVJKzw1J032Z2f42Px9N56fFoFZuhGC9u74jioh9azfr5
    UBlZ31K+27Ya1xGX7sQdpqYy2i6EIEXYzfZP52bosiqButhm0tN/cyZlnW+e/EhtOedTkYHFX5bd
    MVTHBHfnkce/3VXkQlbQj7qoX2BwDDN9zeE4YDSCjcNJ/Tx4AABpa661nFipYjLIa3EfB7bohYHH
    xiOAoI7c8MpqSY4Ddwf4SzX2sZQN0ZSYR16KH6RPq04IOUcoYwQ7GrimbAb4YhZRDvc3cGZY0nw4
    jxjVtzek3CNIj+sbl2Cr2+2hdpP/UN1toYKUm3rgg1nyEudLAcUl+qdyDiSvGa63u5mLJtteGy95
    1KA/D9ZWMGNaHbVnA4FpJO5cCqGfHC+DZKHjQG4BfmY6ioU0naIJf3gmrp49oEDSv9oXb1LMUTo9
    oN1o06Tf+YOnezrAkaOnCq5TERHOsrxwm1/9nk9JCCwzQED4Na4DvSSqtgTdqnnSD60ichNLCJT9
    2hoS44opk4NCTdOgE06EH2UtafxacoRzI6RAY4qwqpy0jLS5ZYWFNNlaQPkUtws9ykC7Oi7McGEP
    3iNCpjsYhcyB1pHrSQnz7qsVf4vpjjuJbZvsinnh8X2obgLcSfBWZqZEpQRUAWonBrpLN5xH85KC
    9iJiyJGyGFsPgAyinGdXYgUHonhsHa57MNgxHGvKd4yvdnmpSNxnr5NCgvzA/itBhoB1y/jCOq+X
    +VC5rB92ra3KuVV3FJ4nzIlA0E1n++jPeUNIAxqqOW5g7rQg1iihzY8OQArT1/oGf4YyAjI=
  </Signature>
</Certificate>

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZbwwAAoJEFAslq9JXcLZCowQAIz5bvz8Hy3OxPVhzDKe5qoO
jCGmvlTER4ll6TtsRFYaXl9s1VKl0EZyXRKMbioWKHkCmsvpzEh06WT5qxo5cdOy
SY+d43U6YRTsMkmSeWIcmlcASpJDK2ioThDQ7i+AayVkiqN6wOaeDi+QpL0O1/p0
htJTBLM9YtxuRMOyrcsccO8YXRTrSAtTbYNMLtbhCeGJ4PL3yCsGU6++tbf3vExi
TrtCO9D7BjiJ7iOyAdYX48edB0XdFVVjG0tc2pXv9ZS5c0arXHY2Fo9rPkFMv7Ib
kgV+7LEhwhxbWzzAXFTFvonXoop2B7AoxCcae0xg5C5E96Derr8D/vsNayVXrMBE
7KWBKKZxFayHRHAe+SCYmkBqmrHKw8PdqNMktoz+WjhUjAELcIkgrUhm8SXgQKG3
G+xs5ixjrwtHfqiD+JOcqwJgslbi2m0m0q31eBJAcygrZGATfJsejYOuWahCPz3T
grCxzdJwswEI4HxHc128a30ugUGzIzde4sPQe7DEkXSgMoeFuPymEW2wxTQVOrbr
htHpimcMs+VAR4CQ0M/3fHnxs82AE5Vrt3KmEwIT9VdI/eyRYy4Up3e8JMHBDnoT
yaNAhzMiq0Jr6+3Fw7SXKXElMpDTKbNLGQfcXCaJVw3jzbcYtS1ry74QYaPAt+Rp
fk8A+vrrT9E93axEq28i
=0lAn
-----END PGP SIGNATURE-----

      if {![::PackageRepository::createOpenPgpSignature \
          $checkoutFileName]} then {
        error [appendArgs \
            "could not stage file \"" $fileName \
            "\": OpenPGP signing failed"]
      }

      if {[file extension $checkoutFileName] eq ".eagle"} then {
        if {![::PackageRepository::createHarpyCertificate \
            $checkoutFileName]} then {
          error [appendArgs \
              "could not stage file \"" $fileName \
              "\": Harpy signing failed"]
        }

        if {![::PackageRepository::createOpenPgpSignature \
            [appendArgs $checkoutFileName .harpy]]} then {
          error [appendArgs \
              "could not stage file \"" $fileName \
              ".harpy\": OpenPGP signing failed"]
        }

        stageOnePackageFile $targetDirectory [appendArgs \
            $relativeFileName .harpy]

        stageOnePackageFile $targetDirectory [appendArgs \
            $relativeFileName .harpy.asc]
      }

      stageOnePackageFile $targetDirectory $relativeFileName
      stageOnePackageFile $targetDirectory [appendArgs $relativeFileName .asc]
    }
  }

  #

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZbzbAAoJEFAslq9JXcLZOX8P/3cpohFWIktE/HRqVMZlw/8W
UVNeV+IWxC0CmiDbSfFm566dKxZxHRKYbfa06nYB7L7TuOSdEbPBR1EttKNfryn+
3hr6gh0RJJ6UgUFsCQtUIoxfSMPu83039CaFg4pWUgavOaBVW/Echh+Dpl2k437f
BxmVZGJhU5/96mG4aRJrTixtoZFXCsYeCqs1WL8CkWZPibhUxwi+9DX57bfu9PsD
g7IYWYC1Qx0QAcOMtQLAEkrJuOobAEoxewBj3wTCm22mewOjx7V3C6DPzBoWsbsa
h4ZwytNmRa4pSZ5BEoA8WdmtEw0exxBBJRC1jRaZj6rMs3a/n2WCDH0TQJgag35c
69Mb2RojxP/ToHJJEmzT90p4EVfosbiDDLws0pV+Vq51iBA6MCgZFOVYunyNhS0+
5vxgWWAj/TVbeVsdyXkPTcnj4uV12rToTVkxeWBUrBsyUHSGIXVGYsDSYgTVxxvJ
DSSE3Hx+t2AKuCbLVujorFGrrROWFPi9H1RbnRVZz43mdATxvAC2vPPaJabd7ibX
QaRdO/3AZ94MwbNHR9RjKLGv9AoxDYH3TkKocTa60cYL40+syRnMflGgR+bgLNfK
6DjVXEtKaTtEfjnPDYlKkpeH/jwztHfVg8k1ycx7h/7oPdyzhB2OYphahjdeEBn6

gUsFvyCiNvUyA8DsR1UK
=LOqM
-----END PGP SIGNATURE-----

    THE ASSOCIATED SOFTWARE MAY NOT WORK PROPERLY IF THIS FILE IS ALTERED.
-->
<Certificate xmlns="https://eagle.to/2011/harpy"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Protocol>None</Protocol>
  <Vendor>Mistachkin Systems</Vendor>
  <Id>1ee23cda-963b-4907-8b48-7d2cafabefe1</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-12-30T01:45:30.8215469Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    UYWw8/kzkKiHZtQUN1LUhJMBtBfMVphxiNKI33Ksq64dZeTti7KzLBZ0LBHP9oQXJ3KBFcZCmi7w
    bRi1sDXa2aA1JvBjsC5VN/nL0+CSyd7FGq2QyusKqx5+vQwFmliy9z6/PFNzvE+NNJao4tCPSxuG
    mht5K92IKHdt3V+nfllV96Pd/dl50gSpCsamKILMHb2WSH7hbTUHxqd9oKxkvTB8FMpJXweE19pl
    3V+kFyYjpukBujFuoV6YGkT7N/ZEyZnrhFzJD05JFDGVnHF4eNX4CbN4uqkFH21tchMIOgGEw9sq
    cWSBNQLsC9jVQ23LClTrAPVY93J9cz+MYr+cJSky/87VJJUGrznSs1mVL0ds+E1SOTa6GkPrTO5u
    K2MCx1NzfNNMATf0SN72/JqdbEIBGWKi5uNQ/iE+vjf6n9/pPlf0BCrYSqZ/GUDejodQhA3rIwtV
    xppi+5oMz+kWPW8fmEzk26Hh1IkOfyL+Guh3xn0HDKTw6U2DHCfIpdOEoofbNYB/10OD+a/1FU0/
    9ru3gmJ79RN+NOmJ6qiUPX17axNhWBvy5qaAqUD8Al4sTlYMNILmLOT81n3l9DXk1TnSPynmIttk
    zPUH78LR2dzabpKphelPX7NxrfgZAZswAkoxCAymMbZUs0VBF8+ApFtKy1mHmyFxFOoqTiWbiajz
    8RGTyY+8/dYfTyfi+YMi1V6vlcf2PfY5AZkiTUm9pYmsNTOtLQ0GPUwyiBZf3HKMAMAFk6Jrjec3
    xIrKkUsaXhuJLaeBAbuTAEfHWQfljims04/hqohDqIuOjc18N40zafMxelLq3DcwFybK93G22WmM
    N08R4WeTDinF1lGa5WvktTD0DVRuhKUbf2SkI88O1wE00a5YrXuO1fuq82++CYUBkRzaNWppt+Wb
    jjrpnt03Iiy/sjWczW5bBXrEdDf0aq16j6MRbzsIHylcq6NqK2IXryPY5P0FbA5ZkyXekGsNCYPp
    nKQM14ogoS6f2E4NPdPnp+CpYds4xAP0IrgA9ttAsmgI64Ho0BhFDJ/PyeO1LgtFH6hUXUy8t5l7
    wbQ+36u+mH0CxbXxXKNA3UwKEixXVjJZRc2VEBMVQ5MOlfFyWozYPvefd7d9ItDUn1biTygAQwXR
    0fRQIdSh5RnM1eKqsFlpDepGpW7jVHaja2YVQbJQ1nEXUM5EkegvaVeVmSUBvdTh05vzMHatJU0C
    Ka38AkJIAcKSsS2GIJSSSiXir760csr1EW9000WGdhxkJq/Lb8rdHUPDNKC8DQ4So+EZSRk2ueb9
    DJup/5oaoYIYVIz8opDWLt6a3wdAZ3AdDcqbP7fL745vTe6aoj0bR/HADpQBkc1D8noTNd6FOkwY
    rEW4R2RVqMtCFE/0sw9KYXWIVHXt42ltGXbsMFtH7c+OYIcSoBiDfrpxr33ht9qo5whMASw6n7eA
    yyMstfVh6P2NL1xOo+bHTapfq2RM1msUxJGaymd4EPySCS9jsuaE6XxvTkUeqPoeolcfwWWkVoj1
    5cHUkQdfSKLsBQrSot4i5cH1PSPiFLiYGOt02mEKyQL/WPsmRL952pGKPpoCLVL8DlrtbeQnc9rR
    EnINufksgOfAggWR23V5ndjNjl7VvwnYZhWG+ESK5DTaiZ55bVAoFbbKmM9uOx44DFGNBNL1qBdx
    hujwP9i0ciwdlzmdBpJowYxOuQufubzKyIIKXoTMnkmYonKI2Qc3z4KRfxtqPYYHWuTMA5St9W3r
    tFf2Mo21wYzK/dvAO7GKOqHoEZ6nWS7bwy4kdKRxm4msME6p5cDbzIFtGDwyOS/p1znvLfGK9EeN
    roJ4sCHUYkEjGPWS9edR61ho4EeSCjWIDH69qqPokVqUx3i4pE/cTtamQKbV/ycX5onO1Ay8lZMk
    4oVwv8vL58kbXbKFOuW4qodQrQPmxXofGX8JHXaWPOgPRAWdmwXZl0FQMlL1++K6f+D06sBHks5c
    Lw+4EqO/3ItKfAf4/p+l6MCECTPGu45iX7CYO0ivQNOulcI6A0PmIe6TYg2WGM8CDalA0JY8xZTV
    MC5DGuc1U9J7OypKl08TRxGm9QeapSTx5v5+uZdzEe1mxX5KJgVvO+LgwI9buiqw5U29esXk1p6o
    X7Ar4YNi3V/vGNUL+nwrdTBcdclHLDwh/YtCy4rffaNjz4YUvLQMPIkDoaTBATlEKQxC2rM51ZLp
    mZqF8UM86/qASzRNAJjb+zLt5/P/8LqRaFdnmrvM3IxSkWUkpyRK/1d32wrA+hzrnNe6IIn5ZtFY
    VdB7kdfQ6D+QP+gJgYnucm7esZfBSMlkkOV1dVWMlXyMuJbU7iXkSojznzOaT9vJiNRWE0mdhO7P
    893u/OyDi5YoN2MOu4OmIdy7GtQo1gOOoCyfnaAD44AMUUJYcv75hp0IalRJ3VLcJGMuU+0ziJXL
    oyCXVrEUqRb7LllwjjykNlCFCwPCaziWE08aPGkPm5N80764KWYHUTFls0+HO/hPw1Dj2NR+VUFR
    HhlMNca2GohkmEm3IAF9nfviR5I/sn6cmnfG/0HLgscn0Agn1sIKdgJgxLD5S1G1ZB/KwlUDwf6B
    4zF3qGvtxIg5FPYm3cPIniJI4IdIwI3HETUjNbwkLpeDS0vU1yHF+bpVEdD+A/RTUYYl//eNtpEY
    lEcn8rplC8SBi//kQJO26bs9WjXo54K9LayXtCH8N/wADkCmjKbYrEJmHZrq7Z1Dg2xMOww=
  </Signature>
</Certificate>

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZbzcAAoJEFAslq9JXcLZHCAQAL5SDPSMrZV7IgVfYoaYgaAV
oqvQqgJMlIup8P1+rBxsV8Zf6WFEqHPXzqbA1q7D55YkDFtyFJUmWwCi5dgmtWq1
7bNlMjCvCUz+RoQfVGSgbJ6zN4LtBKaRUPwpRMk+pdIND/UwEIAUDdQ+AE4YCKap
lnyESsrCGiFgCbP9qN6JyuL390tuV+2oiw/WBs79dMPQCMLVXxo+uVJsCniIpkZj
yr6CMvSYhSQNLKae26OZLqPEVlqup3B+sMV1esRf1ppwAJ//JNf5jRTomN5kaBql
fYWtdjtvOl/ha+/pS710GA5c92cakjaEX19z5dadGQKxqSFTOVBj5C8rS9yPqAD/
4QWBzP2veOeBu0SkICLUB2XErQuOksBzEr/sUlpub33irOIPYu+KfC4POx2B5Id/
7zJArV552/H7QoVhweUbcX2/xl+OnpA57yyUBueDfcNNqnHiImR7btvpY2c/FnZE
6HjecmumpbxCu+XOL5Hj5GKwC6O4HISOlzgcCUAsbPcMj++pT3xXTZpVcCxs97Md
T2+80wonx2/NSwy6FHZKrr/51z7KWcxnkm/esxRi26a5EPFPvXzlLnzrjt7GCK2h
DVDIPyf9N20CCpms5ZCyWidsu47/toE2qcXKbRjTQ8lMcw72ZhHmRqlk1fy5Dgo5
rEOp7G/XV02QjXVJMI9z
=6JwT
-----END PGP SIGNATURE-----

###############################################################################
#
# sign.eagle --
#
# Extensible Adaptable Generalized Logic Engine (Eagle)
# Enterprise Edition Signing Tool
#
# Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# RCS: @(#) $Id: $
#
###############################################################################

proc usage { error } {
  if {[string length $error] > 0} then {puts stdout $error}

  puts stdout "usage:\
[file tail [info nameofexecutable]]\
[file tail [info script]] <fileName> \[vendor\] \[embed\]\
\[duration\] \[entityType\] \[encoding\] \[publicKeyFile\]\
\[privateKeyFile\]"

  #
  # NOTE: Indicate to the caller, if any, that we have failed.
  #
  exit 1
}

proc isScriptFile { fileName } {
  return [expr {
    [file extension $fileName] eq ".tcl" || \
    [file extension $fileName] eq ".tk" || \
    [file extension $fileName] eq ".test" || \
    [file extension $fileName] eq ".eagle"
  }]
}

proc isKeyRingFile { fileName } {
  if {[file extension $fileName] ne ".eagle"} then {
    return false
  }

  set rootName [file rootname [file tail $fileName]]

  if {$rootName eq "keyRing" || \
      [string match "keyRing.*" $rootName]} then {
    return true
  }

  return false
}

proc checkAndMatchKeyFile { varName {keyFile ""} } {
  global env

  if {[info exists env($varName)]} then {
    set fileName $env($varName)

    if {[string length $fileName] > 0} then {
      if {[file exists $fileName]} then {
        if {[catch {keypair token $fileName} token] == 0 && \
            [string length $token] > 0} then {
          if {[string length $keyFile] == 0 || \
              [matchKeyFileTokens $fileName $keyFile]} then {
            return true
          } else {
            puts stdout [appendArgs \
                "file \"" $fileName \
                " mismatches public key token from file \"" \
                $keyFile \"]
          }
        } else {
          puts stdout [appendArgs \
              "file \"" $fileName " is probably not a key file"]
        }
      } else {
        puts stdout [appendArgs \
            "file \"" $fileName " does not exist"]
      }
    } else {
      puts stdout [appendArgs \
          "environment variable \"" $varName " has no value"]
    }
  } else {
    puts stdout [appendArgs \
        "environment variable \"" $varName " was not found"]
  }

  return false
}

proc matchKeyFileTokens { keyFile1 keyFile2 } {
  if {[string length $keyFile1] == 0 || \
      [string length $keyFile2] == 0} then {
    return false
  }

  if {![file exists $keyFile1] || ![file exists $keyFile2]} then {
    return false
  }

  set token1 [keypair token $keyFile1]

  if {[string length $token1] == 0} then {
    return false
  }

  set token2 [keypair token $keyFile2]

  if {[string length $token2] == 0} then {
    return false
  }

  return [expr {$token1 eq $token2}]
}

proc readEntityValue { fileName } {
  return [readFile $fileName]
}

proc readCertificateFile { fileName } {
  return [readFile $fileName]
}

proc writeCertificateFile { fileName data } {
  return [writeFile $fileName $data]
}

proc removeEmbeddedCertificate { fileName } {
  set prefixWithSpacing [appendArgs $::embedSpacing $::embedPrefix]

  set data [readFile $fileName]
  set beginIndex [string first $prefixWithSpacing $data]

  if {$beginIndex == -1} then {
    set prefixWithSpacing $::embedPrefix
    set beginIndex [string first $prefixWithSpacing $data]
  }

  if {$beginIndex != -1} then {
    set endIndex [string first $::embedSuffix $data \
        [expr {$beginIndex + [string length $prefixWithSpacing]}]]

    if {$endIndex != -1} then {
      writeFile $fileName [string replace $data $beginIndex \
          [expr {$endIndex + [string length $::embedSuffix]}]]

      puts stdout [appendArgs \
          "removed embedded certificate from file \"" $fileName \"]
    }
  }
}

if {[llength $argv] >= 1 && [llength $argv] <= 8} then {
  #
  # NOTE: This tool requires Eagle.
  #
  package require Eagle

  #
  # NOTE: Needed for the [getTemporaryPath] script procedure.
  #
  package require Eagle.Test

  #
  # NOTE: This tool requires the enterprise license features.
  #
  package require Licensing.Enterprise

  #
  # NOTE: If the tool base path does not already exist, set it
  #       to the directory where this script is running from.
  #
  if {![info exists path]} then {
    set path [file normalize [file dirname [info script]]]
    set path_set true
  }

  #
  # NOTE: Grab the first argument to this tool (the name of the
  #       data file to sign).
  #
  set fileName [file normalize [lindex $argv 0]]

  #
  # NOTE: Grab the second argument to this tool (the name of the
  #       certificate vendor).
  #
  if {[llength $argv] >= 2} then {
    set vendor [lindex $argv 1]
  } else {
    set vendor ""
  }

  #
  # NOTE: Grab the third argument to this tool (the embed flag).
  #
  if {[llength $argv] >= 3} then {
    set embed [lindex $argv 2]
  } else {
    set embed false; # TODO: Good default?
  }

  #
  # NOTE: Grab the fourth argument to this tool (the valid duration
  #       of the certificate).
  #
  if {[llength $argv] >= 4} then {
    set duration [lindex $argv 3]
  } else {
    set duration -1; # NOTE: Forever.
  }

  #
  # NOTE: Grab the fifth argument to this tool (the entity type
  #       of the certificate).
  #
  if {[llength $argv] >= 5} then {
    #
    # NOTE: Use the specified entity type verbatim.
    #
    set entityType [lindex $argv 4]
  } elseif {[isKeyRingFile $fileName]} then {
    #
    # NOTE: This should be a signed key ring script.
    #
    set entityType KeyRing; # NOTE: Could also be "Any".
  } elseif {[isScriptFile $fileName] || \
            [file extension $fileName] eq ".harpy"} then {
    #
    # NOTE: *LEGACY* This should be a signed script.
    #
    set entityType Script; # NOTE: Could also be "Any".
  } else {
    #
    # NOTE: This is an arbitrary data file of some kind.
    #
    set entityType File; # NOTE: Could also be "Any".
  }

  #
  # NOTE: Figure out which encoding to use.
  #
  if {[llength $argv] >= 6} then {
    #
    # NOTE: Use the specified encoding verbatim.
    #
    set encoding [lindex $argv 5]
  } else {
    #
    # NOTE: Use the default encoding.
    #
    set encoding null
  }

  #
  # NOTE: Figure out the file name for the private strong name key
  #       file that will be used to sign the data file.  Now, this
  #       is checked first so the selected public key can be based
  #       on it.
  #
  if {[llength $argv] >= 8} then {
    #
    # NOTE: Use the private key file name supplied on the command
    #       line.
    #
    set privateKeyFile [string trim [lindex $argv 7]]
  } elseif {[isKeyRingFile $fileName] && \
      [checkAndMatchKeyFile EagleEnterpriseTrustRootPrivateKey]} then {
    set privateKeyFile $env(EagleEnterpriseTrustRootPrivateKey)
  } elseif {[checkAndMatchKeyFile EagleEnterpriseScriptPrivateKey]} then {
    set privateKeyFile $env(EagleEnterpriseScriptPrivateKey)
  } elseif {[checkAndMatchKeyFile EagleEnterprisePersonalPrivateKey]} then {
    set privateKeyFile $env(EagleEnterprisePersonalPrivateKey)
  } elseif {[checkAndMatchKeyFile EagleEnterprisePrivateKey]} then {
    set privateKeyFile $env(EagleEnterprisePrivateKey)
  } elseif {[info exists env(Eagle)]} then {
    set privateKeyFile [file join \
        $env(Eagle) Keys EagleEnterprisePluginRootPrivate.snk]
  } else {
    #
    # NOTE: Default to "EagleEnterprisePluginRootPrivate.snk" in the current
    #       directory (which may not actually exist).
    #
    set privateKeyFile EagleEnterprisePluginRootPrivate.snk
  }

  #
  # NOTE: Figure out the file name for the public strong name key
  #       file that will be used to verify the data file.
  #
  if {[llength $argv] >= 7} then {
    #
    # NOTE: Use the public key file name supplied on the command
    #       line.
    #
    set publicKeyFile [string trim [lindex $argv 6]]
  } elseif {[checkAndMatchKeyFile EagleEnterpriseTrustRootPublicKey \
      $privateKeyFile]} then {
    set publicKeyFile $env(EagleEnterpriseTrustRootPublicKey)
  } elseif {[checkAndMatchKeyFile EagleEnterpriseScriptPublicKey \
      $privateKeyFile]} then {
    set publicKeyFile $env(EagleEnterpriseScriptPublicKey)
  } elseif {[checkAndMatchKeyFile EagleEnterprisePersonalPublicKey \
      $privateKeyFile]} then {
    set publicKeyFile $env(EagleEnterprisePersonalPublicKey)
  } elseif {[checkAndMatchKeyFile EagleEnterprisePublicKey \
      $privateKeyFile]} then {
    set publicKeyFile $env(EagleEnterprisePublicKey)
  } elseif {[info exists env(Eagle)]} then {
    set publicKeyFile [file join \
        $env(Eagle) Keys EagleEnterprisePluginRootPublic.snk]
  } else {
    #
    # NOTE: Default to "EagleEnterprisePluginRootPublic.snk" in the current
    #       directory (which may not actually exist).
    #
    set publicKeyFile EagleEnterprisePluginRootPublic.snk
  }

  #
  # NOTE: The spacing to use before the embedded certificate.  This
  #       must match up with the number of blank lines used with the
  #       [linsert] command used to help produce the final embedded
  #       certificate string (below).
  #
  set embedSpacing [info newline]

  #
  # NOTE: Setup the prefix and suffix strings used for embedded
  #       certificates.
  #
  set embedPrefix "# <<CERTIFICATE-1.0>>"
  set embedSuffix "# <</CERTIFICATE-1.0>>"

  #
  # NOTE: Grab the public key we need to verify that our signing
  #       process worked correctly.
  #
  set publicKey [keypair open -alias -public $publicKeyFile]

  #
  # NOTE: Grab the private key we need to actually create the
  #       detached certificate for the data file.
  #
  set privateKey [keypair open -alias -public -private $privateKeyFile]

  #
  # NOTE: Has embedded certificate handling been requested?
  #       If so, make sure we can actually do it.
  #
  if {$embed && [isScriptFile $fileName]} then {
    set shouldEmbed true
  } else {
    set shouldEmbed false
  }

  #
  # NOTE: The existing embedded certificate, if any, must be
  #       removed prior to signing the (script?) file.
  #
  if {$shouldEmbed} then {
    removeEmbeddedCertificate $fileName
  }

  #
  # NOTE: If the file is an XML file, assume it is a license
  #       certificate that we need to manually re-sign.
  #
  if {[file extension $fileName] eq ".harpy"} then {
    #
    # NOTE: Set the file type for error messages.
    #
    set fileType "certificate file"

    #
    # NOTE: In this case, the certificate file to export is the same
    #       as the input file name.
    #
    set certificateFile $fileName

    #
    # NOTE: Import the license certificate.
    #
    set certificate [certificate import $fileName]

    #
    # NOTE: Attempt to re-sign the license certificate file.  Skip
    #       setting the Id as it should already be set correctly.
    #
    if {[certificate sign -encoding $encoding -settimestamp \
            -setkey $certificate $privateKey] ne "SignedOk"} then {
      error [appendArgs \
          "failed to create signature for " $fileType " \"" $fileName \"]
    }

    #
    # NOTE: Attempt to re-verify the license certificate file.
    #
    if {[certificate verify -encoding $encoding $certificate \
            $privateKey] ne "VerifiedOk"} then {
      error [appendArgs \
          "failed to verify signature for " $fileType " \"" $fileName \"]
    }
  } else {
    #
    # NOTE: Set the file type for error messages.
    #
    if {[isKeyRingFile $fileName]} then {
      set fileType "key ring file"
    } elseif {[isScriptFile $fileName]} then {
      set fileType "script file"
    } else {
      set fileType "data file"
    }

    #
    # NOTE: Build the name of the certificate file name (i.e. the
    #       file where the detached certificate information will be
    #       placed) based on the data file name.
    #
    set certificateFile [appendArgs $fileName .harpy]

    #
    # NOTE: Create an empty certificate object.
    #
    set certificate [object create -alias \
        Licensing.Components.Public.Certificate]

    #
    # NOTE: If the certificate vendor is available, set it.
    #
    if {[string length $vendor] > 0} then {
      $certificate Vendor $vendor
    }

    #
    # NOTE: Always set the duration for new certificates since the
    #       policy code now checks for this.  By default, non-license
    #       certificates are valid forever.
    #
    $certificate Duration $duration

    #
    # NOTE: Always set the entity type for new certificates since
    #       the policy code now checks for this.  By default,
    #       non-license certificates are set to the "Script" entity
    #       type.
    #
    $certificate EntityType $entityType

    #
    # NOTE: When embedding, special handling is required when signing
    #       the certificate.
    #
    if {$shouldEmbed} then {
      #
      # NOTE: Set the entity value to the file contents that will, at
      #       some point, be seen by the script policy callback.
      #
      $certificate EntityValue [readEntityValue $fileName]

      #
      # NOTE: Attempt to sign the embedded file certificate and place
      #       the Id, timestamp, public key token, and signature bytes
      #       into the certificate we created above.
      #
      if {[certificate sign -encoding $encoding -setid -settimestamp \
              -setkey -hashflags {+Basic Embedded} $certificate \
              $privateKey] ne "SignedOk"} then {
        error [appendArgs \
            "failed to create embedded signature for " $fileType " \"" \
            $fileName \"]
      }

      #
      # NOTE: Sanity check that the embedded file certificate we just
      #       created validates properly.
      #
      if {[certificate verify -encoding $encoding \
              -hashflags {+Basic Embedded} $certificate \
              $publicKey] ne "VerifiedOk"} then {
        error [appendArgs \
            "failed to verify embedded signature for " $fileType " \"" \
            $fileName \"]
      }
    } else {
      #
      # NOTE: Attempt to sign the data file and place the Id, timestamp,
      #       public key token, and signature bytes into the blank
      #       certificate we created above.
      #
      if {[certificate signfile -encoding $encoding -setid -settimestamp \
              -setkey $certificate $privateKey $fileName] ne "SignedOk"} then {
        error [appendArgs \
            "failed to create signature for " $fileType " \"" $fileName \"]
      }

      #
      # NOTE: Sanity check that the data file certificate we just
      #       created validates properly.
      #
      if {[certificate verifyfile -encoding $encoding \
              $certificate $publicKey $fileName] ne "VerifiedOk"} then {
        error [appendArgs \
            "failed to verify signature for " $fileType " \"" $fileName \"]
      }
    }
  }

  #
  # NOTE: When embedding, do not modify the external certificate
  #       file.  Also, do not save out the entity value we set.
  #
  if {$shouldEmbed} then {
    set certificateFile [file join [getTemporaryPath] \
        [appendArgs [file tail $fileName] . [pid] .embed]]

    $certificate EntityValue null
  }

  #
  # NOTE: Delete any previous [and possibly stale] data file
  #       certificate.
  #
  catch {file delete -force $certificateFile}

  #
  # NOTE: Export the data file certificate to disk.
  #
  if {[certificate export $certificate $certificateFile] \
          ne "ExportedOk"} then {
    error [appendArgs \
        "failed to export signature for " $fileType " \"" $fileName \"]
  }

  #
  # NOTE: Add the standard XML comment to the file.
  #
  if {[certificate warning -type Script $certificateFile] \
          ne "WarningOk"} then {
    error [appendArgs \
        "failed to add warning for " $fileType " \"" $fileName \"]
  }

  #
  # HACK: Read the certificate file data into memory, fix the
  #       formatting how we want it, and then re-write the modified
  #       data back out to the same certificate file.
  #
  set data [readCertificateFile $certificateFile]

  set xmlNs xmlns=\"https://eagle.to/2011/harpy\"
  set xmlNsXsi xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
  set xmlNsXsd xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"

  set data [string map [list \
      [appendArgs $xmlNsXsd " " $xmlNsXsi " " $xmlNs] \
      [appendArgs $xmlNs " " $xmlNsXsi " " $xmlNsXsd]]  $data]

  set data [string map [list \
      [appendArgs $xmlNsXsi " " $xmlNsXsd " " $xmlNs] \
      [appendArgs $xmlNs " " $xmlNsXsi " " $xmlNsXsd]]  $data]

  set spaces "             "

  set data [string map [list \
      "\" xmlns" [appendArgs \" [info newline] $spaces xmlns]] $data]

  writeCertificateFile $certificateFile $data

  #
  # NOTE: Show that we signed it.
  #
  puts stdout [appendArgs \
      "signed " $fileType " \"" $fileName "\" (as \"" $entityType \
      "\") using encoding \"" $encoding "\" with key " [keypair token \
      $privateKeyFile]]

  #
  # NOTE: Do we need to embed the certificate at the end of the script
  #       file?
  #
  if {$shouldEmbed} then {
    #
    # NOTE: Make sure any carriage-returns are removed as they impact
    #       the line splitting algorithm being used.
    #
    set data [string map [list [info newline] \n] $data]

    #
    # NOTE: Start out with the embedding prefix on a line by itself.
    #
    set lines [list $embedPrefix]

    #
    # NOTE: Add a comment character and a space to the start of each
    #       line, including any blank lines.
    #
    foreach line [split $data \n] {
      lappend lines [string trim [appendArgs "# " $line]]
    }

    #
    # NOTE: Finish off with the embedding suffix.  Also, add one extra
    #       blank line just before the start of the embedding prefix.
    #
    lappend lines $embedSuffix; set lines [linsert $lines 0 ""]

    #
    # NOTE: Append the entire embedded certificate block to the script
    #       file itself, forcing the line-endings to be native for the
    #       platform.
    #
    appendFile $fileName [join $lines [info newline]]

    #
    # NOTE: Show that we embedded it.
    #
    puts stdout [appendArgs \
        "added embedded certificate to " $fileType " \"" $fileName \"]
  }

  #
  # NOTE: Play nice and cleanup all the variables we created during
  #       the whole the signing process.
  #
  unset certificate privateKey publicKey embedSuffix embedPrefix; # dispose

  unset privateKeyFile publicKeyFile certificateFile \
      duration embed vendor fileName

  if {[info exists path_set]} then {
    unset -nocomplain path path_set
  }
} else {
  usage ""
}

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZYiOAAoJEFAslq9JXcLZX2EQALTyvb7HTTVK1V5hT1IjyO+m
Gk8+O7/v3PB/rgWDTmkgAGK2aCXrL44ZN0qR7kYRzf084mV4Xz5s89uKNX5w+ofo
dQ/eNIgeHXOsSehXy2+ry3jQ59JGMhYnc1xYo71UXr7wByOgwKDbfJqMT+ZtTDoy
KU//tbmsZ9TFwWGb5fzxIWaWJWAY5P0jrp/q4x3rp5SSf1kXZq3TWOfYeTkm+NnL
wiCjcuXrFIPLlQqd1JRKKnnjlj3fW0pXZXnX2WQ7TbZp5q7hqXBHZN7loNXnos6E
EaHnBQv48wUXxH3zIodsvBPKxNv2Go/BXx/vo21m9zK4XIDowM1FOMdsRnud7cKb
SgkzFN9tU/4hBSf7IACq7Wt0w87AQ3HoC1NzRgVz/To5KxjAlkToS1ubZJzKrMLR
74DKABWyuTEkmhNKLCnu++at8a5my6z8DiZErTUbJvsEfFNas3zI9AuhhP3+simU
TY5FYfqE9rpwv+TqBVE1aVmsa1akE70ExgUTC/7lcjueNK4kdsbRhai5hzN6YVfD
LCGv7wx78l/prDvd7jZQS+FJELA2eklw149kGdjBV11owqtOkukCjXcO9N6O0itJ
l5zE56RNs7Y20kVAH6Wh85DTbGF0BvkuPeJK5yHjP2ArFM8HU9vWyywwun+v0Cq0
peQOmmcPgb7n0lY+DlAK
=AH2o
-----END PGP SIGNATURE-----

<?xml version="1.0" encoding="utf-8"?>
<!--
    Eagle Enterprise Edition Script Certificate

    The format of this file is proprietary and may not be reverse
    engineered.

    This certificate file is subject to the terms of the license agreement
    located at:

    https://eagle.to/enterprise/license.html

    By using this file and/or the associated software, you agree to abide
    by the terms of the license agreement.

    PLEASE DO NOT EDIT THIS FILE.
    THE ASSOCIATED SOFTWARE MAY NOT WORK PROPERLY IF THIS FILE IS ALTERED.
-->
<Certificate xmlns="https://eagle.to/2011/harpy"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Protocol>None</Protocol>
  <Vendor>Mistachkin Systems</Vendor>
  <Id>a7f379c9-4bd7-4e16-ac4d-738821e26fbf</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-06-29T07:36:59.5371093Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    Fyw8sZV0HIdgwP78cWXEGHQL76NwqmfbEMCxPhFsYk8sOgRl0+QcqgxVhQ6fNS7XvR2/yrWbqxfe
    uJRjiva3noZST8bhJr59EHLRrz0pz7BGbe8M4ytzOusDWjxeax0zekj9S5snszCOpv2YolaNja4t
    RvFsCNKNmZGCTR/8IWfkSez0gg8agiVkrlRwmqAydu+w436/hrPYyYnNz2XdiwFyacgv11wDFbxB
    7tbM/XueEbefac92qJQATO1LUAtQqF4pnIhdN1zWCw87hB3hdcuHY7PyJBJ/3YXhEUJdBGQQN1W7
    P+tFDLij3x67xx9tPrFaF6RSdv9bv9PkwbipKrrJXcSSf64xFxW5DvQ/Rh6MBKxRSEKRZqWTH5vs
    IQJ/QEF/3VHKW1qa+b/OAao6XIBK5VEdegno6EzJup+1bB+LAMEEZgFFht3hNbj5YlHMSxthShKo
    kDEYamOsyX8Dged28dc+cjbA9wGNqJEV/Teh9n2W6n+P+psmnvtk8X+jAT9Gmh9aFaZ16euFD/WY
    JCpl+wFR5H6hjnS23M/VKIEjPthKJaO545G93RkO5E9M5cSzoKH4NJlg2Ygn/JdsoGUUS/pCNwbK
    8ZWiaKsIErwWVbxwqdHizFLeOGKZpVj46PsgousJ+pEJbwGFqlH6EUHT4tn+1IlCI0QZJH2zsoqi
    Qqz/vQDJTeU3NKnn3Bti7uuDQm6N8zAi0k8+LTdlZbGEJinrs5ZFrjWkDNUCyBtropsuDbzYQ5bz
    a7hyV16Zc9tBr1xgXrA+2+cZOBMAAEl8tl9ZUyyBnbctfxVquKhmoe7I4IwJwKLZq/tmAjR6/OfJ
    /0A5KwxNTQRBXny8vLYZMNoV8t18hPVOWLM/plBpQt/64A7zsK9DFXsWMSqWlyBnpgRqREkbIcUI
    rQO/1ptA50LxRyK+bF1qov/NeCZMwoJXZHTtY3jIJp6DUwloS4iaQzI+ZAc/lfl3ygfJhp0e4813
    lWR+fCQbVIAXcHSV15D1KcohOE4kh5PvaR1c1mHonjDUFLaGAlZDEKa1Nhvm1arKkp6cFEfOwcNP
    aphSqQntrchIaIZUP8VCHttj/tvyLlOO6x8IKzI4U+xoQgo+dtGgHSIfOVJjAaLaRCYlTOWcX9+Q
    dBAN2RkhEWB7Hb/O1ue9onELjpsIz1wFmztdtW2M9HRScVYwEMahYMUxXYoOgrONX9ysopX7hSJD
    jGNs4ntFBdZTKcK3uzEv6MMSSiz5VnIJG4BYV6PbclnjwtVS8p90OVpkLjj0UzgibUXB9+qspdvk
    hXKarZld3wIalmYa6iGwGnfobp1hZ52tP9daQr/EkUR2bgv1bs6rTHgOloBWHtERDQm6NmAz/OyR
    BRLdbrFPgZEeoRlVmj4uBgvHrZRhj74qteXBMXayLwxosamOyJevBg9qDNuuMKlFUHhWPpyeLREd
    UO9jm6ya+hZOLaGH+bQOcyh1BMz0JCMJHtN66y7XxfAcZZMVHP89krF2lUmfzMXCsbMzOJW645Vb
    v4DrGLtTR26KjjiOfJJ8MydbwCrwLBSMOx+ExaY1fnDm9xhJdBqPi4iQAC+B/l+aMxmAaVcSJAoB
    uqq6NNTuiIRukk4vV14GQ30pyuG+SyV9WOtYYYllJRpKRJhJqeyv62IrDsggjMqR94NVoVrQvPvX
    w1PDBMr1VwZajMOcZ63wq64enOW8bwfqvYTPEOYw3tvZ5kuf00zaavV5Dsheyo30MV8V3qm+9bFi
    OhsB+38jysN7Ps+BHXwmP0VShRzpLOEeFz1jijm3tz5vAda3Ysn7EahasqmG6x+VKnOi8tPRf0JA
    rWtN0e+KDBbycRwZdVWQS57aTFZZMJlUKlHDsGG0TVRVUpk8qcDtW9Uuz5N8pCGifwMWXce0bJz+
    g/qJtzPf586ZzFd3TumcDkk3FtGMSqmgmXanLwVoEIyWsJI5v97+UTLKGwnbwa7jFiLGW84SHHSR
    p0RApMeMnv1Gs8AvrGXZ2d+NFN1lNTuRbJCkEBFFAis5goozB+WgeuJthVmOJGMZzQ5SOM/6rBdC
    L73e328yo0nP2OTtW8wdjr1JWAP85N+NfArsR66YA/OJldfpvn33ih//POuwpVDQQ8Iig9BhRWHg
    HMBKIoJs7ubzZUnyFt0okhg7tRlJKVD/mPj7H/nsisnaOyHQ8kwpLFHdsAaDmU8pv4kJSjxtJtCE
    nweksWvL7rTPbRpOc6OilXyTKJej4WJcDsOqvv3233Ak2TEEQCvVi4sD9E7Isk0/zp46oOjvV3Rj
    NuAdy0X27fqEo1Vn1jlGA6kMwLAh2oXZlwXsZXHRTJlnJjlsHuc/ZkM0SiMTB393VQkLPXpvqXHX
    tiOw2EZTgMjyCSCDpk5FhFXW8JIiAOynLISo4blMYhq9d1YuIqZBKxlH4Fq3Pgjg7WtqI9UuzUW1
    xL5y8I/koxmYAVQZRRByuwFoXakHYrzFfKr4hmSdU1PW0VhBVxsBQjP8n19dGtmuWNO8h8B4RqCT
    pnjV0IWkmrRNZBudm+jjlULVRa2Q7jWpGIEyaHu7CQzV8hcsLpJSJO1x/CGY5vw/lPHdAhQobZdz
    awMOLExsO8Vy8wJV2Y7EM/7gMKmYkCk5iTFs4RHmH4bhwqqz85e8bu4CIcfDblL368C65oRv+JZ2
    dlYwfhWLBy69d//qFQbDq9WeAN8u+vO+haC6t4Zu72/o1ltmDJkZ5dUhtwiVsw5d98HT0Gk=
  </Signature>
</Certificate>

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Eagle Package Repository

iQIcBAABCAAGBQJYZYiQAAoJEFAslq9JXcLZqTQP/iibodSRxVofN4CKf6wGaPJP
kYX2yXiGE8gMvBK64MiOQoG5sDbA4858+zmsd2EyL68ZEPXZjcQMPXb3hwQW3Kal
MM4WNCIXooq7CYdWkOvBhHbjcAgqN9aW/1K340EPlvxxHwCpy2qLczcUyiDiO2AF
OWOTszqyirh2+Gz/uY/Lqs+QCh2b/RE4SN0YsfbifBKOZF9Eshzyxr/txT50NZ/Z
Wrqp9ny8BX4qtRG9SBzPE760T5d2tIj4wbLkt3ALJOJlUgCPvrVg6E8OllITh4lC
g6ewxgI9TB/NC15TCotN1oerEd5xJi3oPSRyF7uBt2WmIndmdmBo8/bI5Mv+kyV5
THxM9efLuzSnFQzleyPNisTzZ/29eyfHX5yIsSSJMGZ+Mq38ezz4ITwW+dd+JVab
3v6dIKZfna2QZqlQ7PsG8WmuDsdYHZ9UjHb7W1kBWmawtMIWXB4vFRKPUO0tV/HC
JWd1Tf+n5n5p7V4HlxurygFbv8Wh35qh1I2MwsXcM019fErn8p/lZTsgQaB138Mc
+t9H5WwmNtJe1MtFt3hjM/TOLinFOqghNKBKrbvXMZxwwkQ8FGlr+pA9EUieQB0B
Xq1S3SI3g8lT6H6XkpR7EVqs5NOGjQhd3pJXrKlmPuis8mTZ4K6uKycKMeKgl1o0
Zi65wW3bcuEeDejd/99M
=nDvi
-----END PGP SIGNATURE-----