#
  # NOTE: This procedure returns the root directory where any packages that
  #       are downloaded should be saved to permanent storage for subsequent
  #       use.  There are no arguments.
  #
  proc getPersistentRootDirectory {} {
    global env

    #
    # NOTE: Allow the persistent root directory to be overridden via the
    #       environment.  Typically, this customization will only be needed
    #       if multiple instances of Tcl need to share packages.
    #
    if {[info exists env(PKGD_ROOT)]} then {
      return $env(PKGD_ROOT)
    }

    #
    # NOTE: Fallback to returning a directory parallel to the one containing
    #       the library directory.
    #
    return [file join [file dirname [info library]] pkgd]
  }

  #
  # NOTE: This procedure checks the configured persistent root directory for
  #       downloaded packages.  If any checks fail, a script error is raised.





  #       There are no arguments.  The return value is undefined.
  #
  proc verifyPersistentRootDirectory {} {
    variable persistentRootDirectory

    if {![info exists persistentRootDirectory]} then {
      error "persistent root directory not set"
    }

    if {[string length $persistentRootDirectory] == 0} then {
      error "persistent root directory is invalid"
    }

    #
    # NOTE: Either the persistent root directory must already exist -OR- we
    #       must be able to create it.
    #
    if {![file isdirectory $persistentRootDirectory] && \
        [catch {file mkdir $persistentRootDirectory}]} then {
      error "persistent root directory does not exist"
    }
  }

  #
  # NOTE: This procedure returns the name of the package index file for the
  #       language specified by the language argument.  An empty string will
  #       be returned if the language is unsupported or unrecognized.
  #
  proc getPackageIndexFileName { language } {
    if {[string length $language] == 0 || $language eq "eagle"} then {
      return pkgIndex.eagle
    } elseif {$language eq "tcl"} then {
      return pkgIndex.tcl
    } else {
      return ""
    }
  }

  #
  # NOTE: This procedure returns non-zero if the specified file appears
  #       to contain a master package index for native Tcl.  The fileName
  #       argument is the name of the file to check.
  #
  proc isMasterTclPackageIndex { fileName } {
    #
    # NOTE: Read all data from the specified file.  This should always be
    #       a relatively small file with a constant size.
    #
    set data [readFile $fileName]

    #
    # NOTE: Check the data read from the file for the magic string that
    #       we use to indicate a "master package index" file.
    #
    if {[string first <MASTER_PACKAGE_INDEX> $data] == -1} then {
      return false
    }

    #
    # TODO: Make this procedure smarter?
    #
    return true
  }

  #
  # NOTE: This procedure, which is only used for native Tcl, generates a
  #       package index file (i.e. "pkgIndex.tcl") suitable for use with
  #       native Tcl 8.4 (or higher).  It will recursively [source] other
  #       native Tcl package index files that are within the configured
  #       persistent root directory, thereby causing all packages located
  #       within it to become available.  Since Eagle (by default) already
  #       performs a recursive search for its package index files, this
  #       procedure is not necessary for Eagle packages.  This procedure
  #       will return non-zero if productive work was done.
  #
  proc maybeModifyMasterTclPackageIndex {} {
    variable persistentRootDirectory

    verifyPersistentRootDirectory
    set persistentDirectory $persistentRootDirectory

    set fileName [file join $persistentDirectory pkgIndex.tcl]

    if {[file exists $fileName] && ![isMasterPackageIndex $fileName]} then {
      return false
    }

    writeFile $fileName [string trim [string map [list \r\n \n] {
###############################################################################
#
# pkgIndex.tcl --

  }

  eval lappend pkgd(dirs) \
      [glob -nocomplain -types {d} [file join $pkgd(dir) *]]
}

set dir $pkgd(savedDir); unset -nocomplain pkgd
## <MASTER_PACKAGE_INDEX> ##
    }]]

    return true
  }

  #
  # NOTE: This procedure returns non-zero if the specified file seems to be
  #       an OpenPGP signature file.  The fileName argument is the name of
  #       the file to check, which may or may not exist.  The nameOnly
  #       argument should be non-zero to ignore the contents of the file.
  #
  proc isOpenPgpSignatureFileName { fileName nameOnly } {
    if {[string length $fileName] == 0} then {
      return false
    }

    set extension [file extension $fileName]

    if {$extension eq ".asc"} then {
      if {!$nameOnly && [file exists $fileName]} then {
        return [::PackageRepository::isOpenPgpSignature \
            [readFile $fileName]]
      } else {
        return true
      }
    } else {
      return false
    }
  }

      return false
    }

    set extension [file extension $fileName]

    if {$extension eq ".harpy"} then {
      if {!$nameOnly && [file exists $fileName]} then {
        return [::PackageRepository::isHarpyCertificate \
            [readFile $fileName]]
      } else {
        return true
      }
    } else {
      return false
    }
  }

  #
  # NOTE: This procedure returns the auto-path for the language specified by
  #       the language argument.  An empty list is returned if the auto-path
  #       does not exist in the target language.  This procedure may raise
  #       script errors.
  #
  proc getAutoPath { language } {
    if {[string length $language] == 0 || $language eq "eagle"} then {
      if {[isEagle]} then {
        if {![info exists ::auto_path]} then {
          return [list]
        }

        return $::auto_path
      } else {
        ::PackageRepository::eagleMustBeReady

        eagle {
          if {![info exists ::auto_path]} then {
            return [list]
          }

          return $::auto_path
        }
      }
    } elseif {$language eq "tcl"} then {
      if {[isEagle]} then {
        tcl eval [tcl master] {
          if {![info exists ::auto_path]} then {
            return [list]
          }

          return $::auto_path
        }
      } else {
        if {![info exists ::auto_path]} then {
          return [list]
        }

        return $::auto_path
      }
    } else {
      error "unsupported language, no idea how to query auto-path"
    }
  }

  #
  # NOTE: This procedure adds a directory to the auto-path of the specified
  #       language (i.e. native Tcl or Eagle).  The directory will not be
  #       added if it is already present.  The language argument must be the
  #       literal string "eagle" or the literal string "tcl".  The directory
  #       argument is the fully qualified path for the directory to add to

          lappend ::auto_path $directory
        }
      }
    } else {
      error "unsupported language, no idea how to modify auto-path"
    }
  }

  #
  # NOTE: This procedure adds a directory to the auto-path of the specified
  #       language (i.e. native Tcl or Eagle).  The directory will not be
  #       added if it is already present.  The language argument must be the
  #       literal string "eagle" or the literal string "tcl".  The directory
  #       argument is the fully qualified path for the directory to add to
  #       the auto-path.  The directory will not be added if it falls under
  #       a directory already in the auto-path.
  #
  proc maybeAddToAutoPath { language directory } {
    #
    # NOTE: Verify that the directory to be added is valid and exists.  If
    #       not, do nothing.
    #
    if {[string length $directory] == 0 || \
        ![file isdirectory $directory]} then {
      return false
    }

    #
    # NOTE: Normalize the specified directory.  This is necessary so that
    #       we can compare apples-to-apples within the auto-path.
    #
    set directory [file normalize $directory]
    set directoryLength [string length $directory]

    #
    # NOTE: Query the auto-path for the target language.
    #
    set autoPath [getAutoPath $language]

    #
    # NOTE: Check each directory in the auto-path to see if the specified
    #       directory is already underneath it.
    #
    foreach autoDirectory $autoPath {
      #
      # NOTE: Normalize the auto-path directory.  This is necessary so
      #       that we can compare apples-to-apples with the specified
      #       directory.
      #
      set autoDirectory [file normalize $autoDirectory]
      set autoDirectoryLength [string length $autoDirectory]

      #
      # NOTE: Prefix match is impossible if the length of the specified
      #       directory is less than the length of this directory in the
      #       auto-path.
      #
      if {$directoryLength < $autoDirectoryLength} then {
        continue
      }

      #
      # NOTE: If the initial portion of the specified directory is the
      #       same as this directory in the auto-path, it must reside
      #       underneath it.  In that case, there is no need to modify
      #       the auto-path, bail out now.
      #
      set last [expr {$autoDirectoryLength - 1}]

      if {[string range $directory 0 $last] eq $autoDirectory} then {
        return false
      }
    }

    #
    # NOTE: At this point, it is pretty safe to assume that the specified
    #       directory is not in the auto-path, nor underneath a directory
    #       within the auto-path.
    #
    addToAutoPath $language $directory

    return true
  }

  #
  # NOTE: This procedure verifies the combination of language and version
  #       specified by the caller.  The language argument must be one of the
  #       literal strings "eagle", "tcl", or "client".  The version argument
  #       must be one of the literal strings "8.4", "8.5", or "8.6" when the
  #       language is "tcl" -OR- the literal string "1.0" when the language

  #       directory on the package file server and may be an empty string.  The
  #       usePgp argument should be non-zero when an OpenPGP signature file
  #       needs to be downloaded and verified for the downloaded file.
  #
  # <public>
  proc checkForHigherVersion { language version packageName usePgp } {
    variable clientDirectory
    variable persistentRootDirectory
    variable temporaryRootDirectory

    verifyLanguageAndVersion $language $version isClient

    set temporaryDirectory [file join \
        $temporaryRootDirectory [appendArgs \
        pkgd_ver_ [::PackageRepository::getUniqueSuffix]]]

    if {$isClient} then {
      set persistentDirectory $clientDirectory
    } else {
      verifyPersistentRootDirectory
      set persistentDirectory $persistentRootDirectory
    }

    set fileName [file join $packageName VERSION]
    set downloadFileName [file join $temporaryDirectory $fileName]

    file mkdir [file dirname $downloadFileName]

    #
    writeFile $localFileName [getPackageFile $uri]

    #
    # NOTE: Is use of OpenPGP for signature verification enabled?  Also,
    #       did we just download an OpenPGP signature file?
    #
    if {$usePgp && [isOpenPgpSignatureFileName $localFileName true]} then {
      #
      # NOTE: Attempt to verify the OpenPGP signature.  If this fails,
      #       an error is raised.
      #
      if {![::PackageRepository::verifyOpenPgpSignature $localFileName]} then {
        error [appendArgs \
            "bad OpenPGP signature \"" $localFileName \"]
      }
    }
  }

  #
  # NOTE: This procedure attempts to download a list of files, optionally
  #       persistening them for subsequent uses by the target language.

    set temporaryDirectory [file join \
        $temporaryRootDirectory [appendArgs \
        pkgd_lib_ [::PackageRepository::getUniqueSuffix]]]

    if {$isClient} then {
      set persistentDirectory $clientDirectory
    } else {
      verifyPersistentRootDirectory
      set persistentDirectory $persistentRootDirectory
    }

    set downloadedFileNames [list]

    foreach fileName $fileNames {
      if {[string length $fileName] == 0 || \

      file mkdir [file dirname $downloadFileName]
      downloadOneFile $language $version $fileName $downloadFileName $usePgp

      lappend downloadedFileNames [list \
          $fileNameOnly $directory(temporary) $directory(persistent)]

      if {$usePgp && ![isOpenPgpSignatureFileName $downloadFileName true]} then {
        downloadOneFile $language $version [appendArgs $fileName .asc] \
            [appendArgs $downloadFileName .asc] $usePgp

        lappend downloadedFileNames [list \
            [appendArgs $fileNameOnly .asc] $directory(temporary) \
            $directory(persistent)]
      }

      if {$persistent || $viaInstall} then {
        set fileNameOnly [lindex $downloadedFileName 0]
        set directory(persistent) [lindex $downloadedFileName 2]

        file mkdir $directory(persistent)
        set command [list file copy]

        #
        # NOTE: When updating the package repository client files, always
        #       use the -force option to overwrite existing files.
        #
        if {$isClient} then {
          lappend command -force
        }

        lappend command --
        lappend command [file join $directory(temporary) $fileNameOnly]
        lappend command [file join $directory(persistent) $fileNameOnly]

        eval $command

        lappend downloadDirectories $directory(persistent)
      } else {
        lappend downloadDirectories $directory(temporary)
      }
    }

    #
    # NOTE: Does the package need to be persisted locally?  This can be set
    #       via the direct caller or via the installer tool.
    #
    set addPersistentDirectoryToAutoPath false

    if {$persistent || $viaInstall} then {
      #
      # NOTE: In Eagle, a slightly different command is required to delete
      #       an entire directory tree.
      #
      if {[isEagle]} then {
        file delete -recursive -- $temporaryDirectory
      } else {
        file delete -force -- $temporaryDirectory
      }

      #
      # NOTE: When dealing with packages for native Tcl, modify the master
      #       package index.
      #
      if {$language eq "tcl"} then {
        set addPersistentDirectoryToAutoPath [maybeModifyMasterTclPackageIndex]
      }
    }

    #
    # NOTE: Sort the list of directories that downloaded files were written
    #       to, removing any duplicates in the process.
    #
    set downloadDirectories [lsort -unique $downloadDirectories]

    if {$useAutoPath} then {
      #
      # NOTE: The auto-path, for whatever language this package belongs to,
      #       needs to be modified.
      #
      if {$addPersistentDirectoryToAutoPath} then {
        #
        # NOTE: The downloaded package was persisted -AND- will be handled
        #       by the master package index; therefore, just make sure the
        #       package persistence root directory is in the auto-path and
        #       then return only that directory in the result.
        #
        maybeAddToAutoPath $language $persistentDirectory
        set downloadDirectories [list $persistentDirectory]
      } else {
        #
        # NOTE: Check each unique download directory for a package index
        #       file.  If a directory has a package index for the target
        #       language, add to the auto-path for the target language.
        #
        set packageIndexFileName [getPackageIndexFileName $language]

        if {[string length $packageIndexFileName] > 0} then {
          foreach downloadDirectory $downloadDirectories {
            if {[file exists [file join \
                $downloadDirectory $packageIndexFileName]]} then {
              addToAutoPath $language $downloadDirectory
            }
          }
        }






      }
    }

    #
    # NOTE: Always return the list of directories that were actually added
    #       to the auto-path, if any.
    #
    return $downloadDirectories
  }

  #
  # NOTE: This package requires that support for namespaces, which is an
  #       optional feature of Eagle, must be enabled.
  #

  ::PackageRepository::maybeReadSettingsFile [info script]

  #
  # NOTE: Setup the variables, within this namespace, used by this script.
  #
  setupDownloadVars [info script]

  #
  # NOTE: If necessary, add the package persistence root directory to the
  #       auto-path for the current language.  This will only be done if
  #       it falls outside of the existing auto-path.
  #
  variable persistentRootDirectory

  maybeAddToAutoPath [expr {[isEagle] ? "eagle" : "tcl"}] \
      $persistentRootDirectory

  #
  # NOTE: Provide the package to the interpreter.
  #
  package provide Eagle.Package.Downloader \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}


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

iQIcBAABCAAGBQJYBbdiAAoJEFAslq9JXcLZC+wP/0TeacdSKVxp7/XcGjoUNW9P
iiCPLqG2QQ0E1E2hR/pkyVsf8zppjFyUxQbPvzlca89vT5/f0YzHPx7V00rwGupY
wr3jHXP4yT2EZ1EvRQr5DxHgIbXUnxBUmiIE6h3QzA4y32yfD4WenEy01SuiVw99
BvDa4T1e/WXTpMckf4QGwZ8i9U+EEcYcBud2KV+y2TabtHOPMP6K5PFQcyNfmKtd
ptm3wIyn92VAnkiEcI5BvK3fWFquCsum6Q7XsY4/7gn9StKiAC/ohrhwyWaE+rVv
NxaAv4/XbgjrAurrVoozBmtph+dcM0GzQXJ8PMDoqAxq0jgHtFL+075KrEDcGuix
lBX1XaDyz8OeAux0cZxGUPnvqI0KfvTIYYyo56uR6kZ+TEnf6FDRY+g6Y653jU/T
0gvcg820fpqjFa5zNRj3f4X58nhdW1bqllruZxZljTm65DMsVHyqA1liaZlq94tv
N9/PTfGj4NtF0bC1LqbKNO/Z/pvYtwfMBFEBab8P6CJb8WlWVwvjLDiVfscQ2zZx
JeJRHygELZp/BNwtluDYrEH9lxiyct4x0FHggYMylCYLBdfnsOiCX6G6ecIhgokR
nWAHbN9DOKZIPLThQU6xZ52UMqUIkyWqyJ3rZZv9mSZYnwVkojEmuYWgYL6QlDVX
pGAQh9Wz+7khXrfQdC3i
=4L9D
-----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>a912d50c-3171-48a7-81d2-1a95025d18a4</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-10-18T05:45:09.9171172Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    F5nakHt4pZF1YHdeFQvpm0Xmqei5v/Pf2/lH6D3gyJE48LWLIxTvhb3h1rmwoJPUj3qiqrNEwfdp
    uuQgpaVc4jIrI7W5katANZfLBmXw5vM+K+dPCYOitYEeNnKJQ1nKqgs7Lnd8+2jDONsDVzmygDUv
    vQCs5PZQJRxLF75iXWMCYJpHJjYRQ96FnTAPE7lwhF95Mmw889rwAih8JK13QHtdT6bB9NbAivex
    NSCKvCZ/GPE/FeKQ36zWd5QlXNkd+1QUkvXEb9OZm08lCNkGeuISqsgbvCwBV7jqkCijQdPDuVsy
    Y1COvlDCf/OheaAoWW2rH1oclTu9mGiNOCPcNkdBt4Mm8yN/t33jm8bgMK19vOMAE+bd3Taxysbh
    3Tu/5ki/hr2VTj6SGGCUPsUhZJ2klhenfCPIR04jEEwp17rICPWsbqqSFFzPYc2CTV73bgFTcj4b
    jieTgljanf3JYJIoaYDNbewMHPigQaVLL28kQbuKPXP8kK0uIODZQmK4CIXUNEKM6JQUyH3qRP8q
    VMfNfcdED8iQSYUOHqKKoH3TGbltxoYs2wYrUu4uc0+hKIwejr/Y2oZx3Mbhgs5kF3wPpahxFN3b
    SsfHld+LSsA4ikisOK7dnwtrF8dr4qzaYZ2aPi63sfl8Nm99ePgQAaMEWlwIbGICltlHtnBehbrV
    CHFDlax9ACNjiyBV2gNkx8LAFaoBWP7kkvAVtu1IuZhQxtwXmzcvZTpbZ02LDP85OKNRfyq2BV4k
    o4+jMdJ626OjU40SICOcwH2sxTFhy8U/oBI+9C/twWbNTYVB07TyCphrjLziaj4eCCekwQlu0Nvj
    0dHQBjq+f6vgrcjFaSA46P1SQDcWEhP6oC+syXdDlUBZl/KTi8f2Z6FYpaFaic86aNow4VWYVnqX
    tBDkUevXrKugyHNyaVISluoAhJrFzJswXR0HSAVxcZP3LnQDjZIedqmpJMkks+aR/MwjAcF6XXfJ
    sPzLDv5zAnkElyq+Ew2znz/ITfhrgh8ViPxIrqNqMJUv+SMQ5cRZYQVNoBTBfspXhRASADaI4izi
    CbwCbixqouKKEbKSdGBkyt3rHUwPsPbUkS5UfyBW739htPrswynQt8UwJENyiFdiGWP02xexkc/8
    hoaZBcs21ykUHFuTBBKypld8rQdYDynV0/Yq8VsDisJHyirrttSjx7UZx9l2RAcx3ZSbvxnIs/nj
    FuEcb1Kp0zliMLp9AIqawL4EyZN3bjs6hkMp507rpo1/S9X/CxQ5EWGHC48NCZ77qqkTYmZs3/fS
    i+l6M2A5lyoyqOF8KZ6o6iSkmQzz5yljY2s5tdARhE5JsJnt1PCAVwA+tpV914Z2B3dLHvcvr5yq
    rTuN/4JfAE75i44ppaCiIGcfDlSFr3Xr2+UtELKCqpsvmhrZw8Deh4QT3GFBDMLRt/29siB/rsH1
    FZm04unOQq4jmuU/5f8TmwzDbIe8u1tP2JX6dWhdLpRIFt6CFnhlFRS5kPxsCklF4Q1San9neUUw
    PRsaWbs+ZuO/uHEFgXp6D7OmjQEi99BRM7oBoHooJ3veETGEnmAx9JvtjcgD1v2yw1Oljo/gTtZ5
    yYUO08vWbVW0Em90A06oBHKS1gCgxhlIrLyFeB8v3QOqzAS3+dPed+s6z/+Lqx9Mgi/udDtoAAgs
    b3gj2E+FjEtgsq0ei/igMLIfpbbetvFEDYNSrpZwOb0FFJKIvWnA9tVc1o6HSRnlpbkCePTGJ482
    +qJ+nfW8+4XqI7d+vUTOEXQsJZ/iYZKv/Arg/iQlmd1zmo5p2Ks9OP6G85KWoE0hqz8Vy1wODa71
    6C9jJaF55j0Y6z/UU6UpOFOHX8TLbnEx5DxCanqsMT+EtXwJNER0aZoF0F9kbcOw4B1IBIF8sww/
    qjYpxIsoIUxQS1mnkMJKmh32oOxasJ3HQt8RqRErOWxR1/OJ7xwQO8rcw+IGLi7wj60g3909HMOj
    TANHMk+AU/Ud6HU804yUA7OBqyHaXzZnURes7rc6Zhr3QCAj0C+9/dv1LI3sOVB2ziMvWBOkIXpe
    IHdZp+mmDrCQ7CxpO0f2xLwXutSsYysV1JZLFS90WdxxpEmTFIF9/KaQR/sNs3s2P2qlgVgqWYHY
    GUGOhbPFLqKfoVNNGWjYsqZJ5t3ruwASZW8oKYAgiz87TEhWKo+AZ+M20YDCLfnOcF8nrWPDot9A
    aeh4c36ewkVc3QRtJq2Dr51IUFLZi7cxxc5JHq8aZNT+wSX5X7fanrRkLcBaRiDhuHgdDCRKu4x9
    eLv6Nba2o8t0x3Xuz6Ri2AX5yid+KrEzpLRQbps2JPOWaggDcSvB9TCO2ZZjvYycNs7VF8gsMtgc
    60AmcQAvAG48yJmL4TNGOr9sD0KDoG+ty5x6nWSpnXPBZNGD7mw58nUhnVrXNuhmibX8RCaPKaXj
    zRzf5QQIKzlx4USO2t1ZprSnJ0qOtp02XceaZ6OT5evkiDvXHLyiwsoChxxd+kzZtrHPtegJjE0a
    p0p31D7bH+HOYxLZaf38L8/s+eoRmxe/zjp5kTMHdTtCt9WO8gDTRD9kekCQuiU/qPzFRRGrF0f4
    bUIvCh+jddxs0D65AvXoE3HByKvtUv9rt/Q5y7h9HaUEnhPQUUWxKA69/kthwZsLhBdSy8q4EovI
    ZQKi7mcNagT6has23ljGIZ4TPJ7rD2yqy8UMF3NCsK687io5DAqZHoxe4M5GXZdahWgQHuc=
  </Signature>
</Certificate>

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

iQIcBAABCAAGBQJYBbdkAAoJEFAslq9JXcLZl7oP/23sOD1PpaYZAxEJ07AuQBeV
IAA71jqm5VGUXoIcbODxMkdK8BCPcVon3bcsetr0Bpud9ZB93BFCg+8rzmu54kId
M/5cUzWwN2Kl0/yCFqENUV1JdPAtsENjBisKOw6C8tLJJoUZJG2r3L02j4l566dU
2IeVfkd9qw9zcahYXUmfTJNa4x/Skph85QQyUY1gjkVKAipMyrgxvQm4P4/M9fkD
GST66LzIoMEqZ3LpnLJ8coapxHdz//4v7Y28dkpCwK+7DPXINSSHvHqcspVIlvGi
w16Xt7ZTMcyejXXN+n+SsGBxtb/C3bXc9qsyAhuIfenX3QONShPIyxL4YUj5fBMV
I2jD6oklQ/UidDitHeox5AII9mz23Qq0Qk/vVCX0nGqmsgg/+1Ope3Tx+uRPTrp2
z/f8P+CVcWvqIl2NWqEoGEOCOKqBuJPNsAJ05/MzSMVK+66XbA+7G6PIGYSXouFS
1wB0cOI3zvpvILNe53ZchKo3S0iAwB5/3/uyxKE8Kg9LMWQSleosPLT7TcXP1xP3
T3Y4tgggBCGDb9u6YzzTDWTPZ0GKt9ZhjJm+Os+eHHKgj4i9+MDYIkm1fryiKDPO
mzRsW33EN7bsjFJ+y8KqjiMlgZtN8eSfCdIefos4x+y4I4MJ6n04xNBmyliID72X
Lc4O+yPj9v6eik4db2gW
=1i2t
-----END PGP SIGNATURE-----

# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# RCS: @(#) $Id: $
#
###############################################################################

variable quiet false
variable persistentRootDirectory [file join $::env(TEMP) pkgd_override]

    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>a4a30140-8aec-40b7-89af-44cecdef8193</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-10-18T03:47:22.9220000Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    f6cAq6Lfc1MvY8Af1mRIuDqC37TUTIJ6gTnYqMkHIByR2gjxqvjiZ7OVK62kdi7ScTVMgc6SP7Fc
    9ZtLjk4dIHSlAZVVK4GRvPnmtP1UGazqsAhvOOSKteH4VlEDFF1gU7GE8daS9i0yYNJhL7aUspEj
    bki20aex55+jOpr2/yu8doE4KEwBMZfrnnNvOTNt7mdNwenzLCeHu4BZo2rs5oC+Yqumyo5d2t7z
    r86OZOqEhc62Y54fQjFn+he+MWGIb3GObmdTR8EQANPNgiJm28z90WZtortIAV65qPAWVOqVeVZC
    k9G08PhI8Ul2HSMTD8hppTz14L28cI0zvz1R78L7bLoV6npKa9WayCX5Y1KWwfJZGUL2n0hwZczV
    YiHDmYVqFTBDu2EorsjT2ow9fxW42V+S5NQFEFq9ZX9dOE5gGN+O692NnXO0MI/Cgwr3sbCw2oMg
    CIy2Z69sLdbHn1s1ZQJbL7/a80MSEmOCN2z8hyi9UwiFIz+KZWHig+vevEGNnUrUb8nNb99A1evy
    f1Hn+hS1M5HrhLNEEs3QDKzWk5LUK3REkmUe8AeZ2rJF1Gd3R2DmFBJvZ5QSKMm15ErIlb8tPONJ
    2zem6VC8UAz5JIIlcThGTARIIRSzpFx7P6qduhydZ+PKSdKD/ZUcbl4Uy4yb9558KnDi9GuJPnND
    O3DtybDUbgltpFAc2EwIY8mITmF/E0bzD1M8EoLJvEHS82YJHmTr/KA3YYzKX94MD9zW8wgk6h3W
    igIP7A2h5fLBXyVAlY2ED8SD6p7vHQadxaWanYbPd2DEjpmvyQ7aSStGBzX1VrtD+c4Xkw8MZLc6
    Pvio6Z5PXtL8CjEdWytgo2itzh5w32naAsaripDJ9eq0Mucu7FYQLPcdHqDS1NFmcNrSttbp/Qqd
    ButKEC0sTbVfxRiRgewAyeKB2dz6gxrgbfhzqkqrVJlZcqzYbijjpxRnwEWoJVR+RcZy/8wZS5DJ
    9WoO+sL20QvFlMW6qPkUDKbUTpSel1SsecakDN9BnNQlBCRN0tORmZQMNCKSEOwWfZd0T61KJ8Jc
    P9tY108eYFWE/E2/PBf7p1foLRQTgIpEodWyNsgqMj9rd6kBx/xNmradJv69Cw+RXh2JCgcpB86H
    qovnsfZh692tOxnQp1YWRqSWZOqqc5jok5T7pHtEh4XTzLKhHc5qLRfmVsbNZl63yoyStJST5+Mt
    qgM3fH4R50MzsXZA+7AAvKn2f8bfrn9STPCEREHZDJndO7IHPPC2F4Eogvb5ph7iisj2UhI7neeW
    xFf/rL+6zDWCpz20FFsXltrkd5mLrUiqnTTPuFBHb4Xq0NX6/4W8hYJITdKxLzjm0Rk2yd5j4jT1
    Oyyv7ZXJXKedembzlmYLGdmf3y4i0hB8dynmuiYyHzWg90haCAJxFhVcgB7wRL+heG8h+BMXqtdw
    R7ktLM8aZlUqElJxLcFWUg44LKAM9MpO1mfClfkHyQk6EWplpMF3GjEsEfBqk8twgvsczVrzwS6j
    bi6aM6siM0WpDfI23cPlJHUvD78hFZWmGbmqTtMk8WfVf08+BG4YmdKq4b3guK41fdXeLzNqBvbO
    V7ApCzN/4JZIYod5I1MUc1CEY3rM12uFKsY285ZtosY8AT/KLZjAUMy6Q64iNbCaiaWXDMnEVYYO
    D2SN67WHmf3keh+L/U+md7/IjE8ed3scCb7fMNr+8pLo4RcTKrgThKWjoxR1Mb64STQ8o32t3Q/d
    qnnMuyMT+wQKwyIIRHGCLdWslthFwyGEPyggWYegdCwr65PHPbM3wy+9kXZs/tumVUjyMyYM8Yqn
    XeEHBzi1ofBvZry4WTIHFju1X84UphCvOldLJyh/KYEpLIwEgGp9cJ7Zzcg2fMop7Vvll33Lzvp4
    XVXz8tta9BL0D8tpfuaTsYIwGjGLPpV9A9Xl4VHrA2rJyGXRxdL5Stqb7VbhQEr+tJfdW502pONu
    peg3u8vnynWaijM8wrxJxGP1DegFjFwwqbZfnYWrCjvBieVQZ31n7nG+MiDySxrOIRwvJYXLVjol
    aje7S7Rb90Ht40dqJ5/e2jSQkzdWGcf32yTdBnUAqPYmTnPlONtYRlgktrQKAKEvuSzGxrPLR3O+
    huqNVKQOhy8r2NpGQt7UbyKp3cT6ozaCe42FNDQt6XQ4LDpaNwVYkZLlgodCkuxFZr9MLC3XDNOe
    kUXL/a2MD4b7vq7cqFfL0Hc4+CRXicBZkW8WV9uTNHH9bHT0wEIqxynexlYCwa+sZW76em2h3tc1
    LZluObrx1lOR6/+ZvTUyeG1YyoPNcbumxqhgwRhB2N40TXSFHXxmKeCyK+0ueJ6bqeMvzQn6XXgR
    DXcYhJNrul5YL3WPnSBqIiykqZH6sXeknfPVaHexG54GMSgpK9Zod6QYCUezEzV7yu2OQpoYzPK8
    X14+1EqB9ybaYBwGZQhLe7g0RiBqiWlAKk9OqXaeTpL8Tqnar+fX+T8bviw/ZEkBGtaL6ghMJQA8
    Yup722nAaxBOvdHg91PN+JZKy8kFqhrFpPFL5BKfD+1WwARjqhp+oJqRUhbPlpgTkBIWIOqA5NKM
    y5vxtCVB2FOAhtj6qHANg1gLNzkHRgOJzv5E08yfjetY600+UW54Rgn2iR/4o1AX7I3n4DzbrJf3
    LXfhGvWA+ftu9kI+EOaknJ2Qq+AwVKp+8DQgjBPK22D+LbMZ4mPAQ2Zif6H3H3MECpdvc8Y=
  </Signature>
</Certificate>

      2 {set codeString return}
      3 {set codeString break}
      4 {set codeString continue}
      default {set codeString [appendArgs unknown( $code )]}
    }

    if {[string length $result] > 0} then {
      return [appendArgs $codeString ", " [list $result]]
    } else {
      return $codeString
    }
  }

  #
  # NOTE: This procedure emits a message to the package repository client

  #
  # NOTE: This procedure returns non-zero if the specified string value
  #       looks like an OpenPGP signature.  The value argument is the string
  #       to check.  The value 27 used within this procedure is the length
  #       of the literal string "-----END PGP SIGNATURE-----".
  #
  # <public>
  proc isOpenPgpSignature { value } {
    set value [string trim $value]
    set length [string length $value]

    if {$length == 0 || ([string first [string trim {
      -----BEGIN PGP SIGNATURE-----
    }] $value] == 0 && [string first [string trim {
      -----END PGP SIGNATURE-----

  #       in the specified (named) file.  Non-zero is only returned if the
  #       OpenPGP signature is verified 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 OpenPGP signature
  #       file to verify.
  #
  # <public>
  proc verifyOpenPgpSignature { fileName } {
    variable openPgpCommand

    if {[isEagle]} then {
      set fileName [appendArgs \" $fileName \"]

      if {[catch {
        eval exec -success Success [subst $openPgpCommand]
      }] == 0} then {
        return true
      }
    } else {
      if {[catch {
        eval exec [subst $openPgpCommand] 2>@1
      }] == 0} then {
        return true
      }
    }

    return false
  }

            [namespace current] ::getFileTempName]]]

        eagle [list proc $newProcName(3) {} [info body [appendArgs \
            [namespace current] ::tclMustBeReady]]]

        return [eagle $script(outer)]
      }
    } elseif {[isOpenPgpSignature $metadata(certificate)]} then {
      #
      # NOTE: If there is no package script, there is nothing we
      #       can do here.
      #
      if {[string length $metadata(script)] > 0} then {
        #
        # NOTE: Figure out temporary file name for the downloaded script

          writeFile $fileName(2) $metadata(certificate)
        }

        #
        # NOTE: Attempt to verify the OpenPGP signature for the package
        #       script.
        #
        if {[verifyOpenPgpSignature $fileName(2)]} then {
          #
          # NOTE: Delete the temporary files that we created for the
          #       OpenPGP signature verification.
          #
          eval $script(cleanup)
        } else {
          #
          # NOTE: Delete the temporary files that we created for the
          #       OpenPGP signature verification.
          #
          eval $script(cleanup)

          #
          # NOTE: OpenPGP signature verification failed.  Raise an error
          #       and do not proceed with evaluating the package script.
          #
          error "bad OpenPGP signature"
        }

        #
        # NOTE: The OpenPGP signature was verified; use the downloaded
        #       package script verbatim.
        #
        set script(inner) $metadata(script)

          }
        }
      }
    } else {
      error "unsupported script certificate"
    }
  }

  #
  # NOTE: This procedure returns non-zero if the specified package appears to
  #       be present.  The package argument is the name of the package being
  #       sought, it cannot be an empty string.  The version argument must be
  #       a specific version -OR- a package specification that conforms to TIP
  #       #268.
  #
  proc isPackagePresent { package version } {
    set command [list package present $package]
    if {[string length $version] > 0} then {lappend command $version}

    if {[set code [catch $command result]] == 0} then {
      pkgLog [appendArgs \
          "package \"" [formatPackageName $package $version] \
          "\" was loaded: " [formatResult $code $result]]

      return true
    } else {
      pkgLog [appendArgs \
          "package \"" [formatPackageName $package $version] \
          "\" was not loaded: " [formatResult $code $result]]

      return false
    }
  }

  #
  # NOTE: This procedure returns non-zero if the specified package appears to
  #       be available.  The package argument is the name of the package being
  #       sought, it cannot be an empty string.  The version argument must be
  #       a specific version -OR- a package specification that conforms to TIP
  #       #268.
  #
  proc isPackageAvailable { package version } {
    set packageVersions [package versions $package]

    if {[llength $packageVersions] == 0} then {
      pkgLog [appendArgs \
          "package \"" [formatPackageName $package $version] \
          "\" is not available: no versions"]

      return false
    }

    if {[string length $version] == 0} then {
      pkgLog [appendArgs \
          "package \"" [formatPackageName $package $version] \
          "\" is available: no version"]

      return true
    }

    foreach packageVersion $packageVersions {
      if {[package vsatisfies $packageVersion $version]} then {
        pkgLog [appendArgs \
            "package \"" [formatPackageName $package $version] \
            "\" is available: version satisfied by \"" \
            [formatPackageName $package $packageVersion] \"]

        return true
      }
    }

    pkgLog [appendArgs \
        "package \"" [formatPackageName $package $version] \
        "\" is not available: version not satisfied"]

    return false
  }

  #
  # NOTE: This procedure returns non-zero if the specified package can be
  #       downloaded, i.e. because it is not required for the downloading
  #       process itself to be functional, etc.  The package argument is
  #       the name of the package to check.
  #

  #       here, because Eagle does not add a version argument when one is
  #       not explicitly supplied to the [package require] sub-command.
  #
  proc packageUnknownHandler { package {version ""} } {
    variable verboseUnknownResult

    #
    # NOTE: First, run the saved [package unknown] handler.
    #
    set code(1) [catch {
      runSavedPackageUnknownHandler $package $version
    } result(1)]

    if {$verboseUnknownResult} then {
      pkgLog [appendArgs \
          "initial saved handler results for package \"" \
          [formatPackageName $package $version] "\" are " \
          [formatResult $code(1) $result(1)]]
    }

    #
    # NOTE: If the saved [package unknown] handler succeeded -AND- the
    #       package can now be loaded (or is somehow already loaded?),
    #       then skip running the repository handler.
    #
    if {$code(1) == 0 && ([isPackagePresent $package $version] || \
        [isPackageAvailable $package $version])} then {
      return
    }

    #
    # NOTE: Next, run our special [package unknown] handler.
    #
    if {[canDownloadPackage $package]} then {
      set code(2) [catch {
        getPackageFromRepository $package $version handler
      } result(2)]

      if {$verboseUnknownResult} then {
        pkgLog [appendArgs \
            "repository handler results for package \"" \
            [formatPackageName $package $version] "\" are " \
            [formatResult $code(2) $result(2)]]
      }
    }

    #
    # NOTE: Next, run the saved [package unknown] handler.
    #
    set code(3) [catch {
      runSavedPackageUnknownHandler $package $version
    } result(3)]

    if {$verboseUnknownResult} then {
      pkgLog [appendArgs \
          "subsequent saved handler results for package \"" \
          [formatPackageName $package $version] "\" are " \
          [formatResult $code(3) $result(3)]]
    }

    #
    # NOTE: Maybe check for the package and then optionally log results.
    #
    if {$verboseUnknownResult} then {
      set ifNeededVersion [getIfNeededVersion \
          $package [packageRequirementToVersion $version]]

      if {[string length $ifNeededVersion] > 0} then {
        set command [list package ifneeded $package $ifNeededVersion]

        if {[set code(4) [catch $command result(4)]] == 0 && \
            [string length $result(4)] > 0} then {
          pkgLog [appendArgs \
              "package script for \"" [formatPackageName $package \
              $ifNeededVersion] "\" was added: " [formatResult \
              $code(4) $result(4)]]
        } else {
          pkgLog [appendArgs \
              "package script for \"" [formatPackageName $package \
              $ifNeededVersion] "\" was not added: " [formatResult \
              $code(4) $result(4)]]
        }
      } else {
        pkgLog [appendArgs \
            "package script for \"" [formatPackageName $package \
            $ifNeededVersion] "\" was not added"]
      }



      #


      # NOTE: Check (and log) if the package is now present.  The return

      #       value here is ignored.

      #
      isPackagePresent $package $version


    }
  }

  #
  # NOTE: This procedure evaluates the package repository client settings
  #       script file, if it exists.  Any script errors raised are not
  #       masked.  The script argument must be the fully qualified path

      }
    }

    #
    # NOTE: The command to use when verifying OpenPGP signatures for the
    #       downloaded package scripts.
    #
    variable openPgpCommand; # DEFAULT: gpg2 --verify {${fileName}}

    if {![info exists openPgpCommand]} then {
      set openPgpCommand {gpg2 --verify {${fileName}}}
    }

    #
    # 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

iQIcBAABCAAGBQJYBbdnAAoJEFAslq9JXcLZxPQP/i4KZZMEwqs+jQfPANo5f8qP
+9ssu+DFplo1Hsap5yt/ny/fLvnKad2BFJyk4H9ZiwDqlW2LRig3Y2TBMLqV79L2
8f2WOBXQcDeKEYez+pl7DlzIYHrVl8DVnBcBdXpB5HTIiKgQdknR9Zvd3v2cukYd
wLyRY6AgIvFWGKA1zt2+ahKaf6owVhihKN2z6yU7EedpkiqaIiE8thUJ73wKLdZK
jpnYVHo5TQE3t0q2Yd22pE2a9DyxXWXvSvpAwqHEhOiA6i4o9UPfPWyK0vp6h7ch
VB+AE5Ge5oMiZPOlpRo69nKzZ//EGddPm1BKJMEWFIJHAVXD4jEORRIGP/Xjz3JD
GpslFcS/bOdQeiPlI2niKd9r/sIlGqw9BNC2FkVGGdvhfCE1VGlxt7ztY3nhYskm
oCKwu4PWfub5uzi4gm2cqB8/42SMxec7oSersdc53QK+IHHPLHe3DBer8FnfGJ9F
kcLMPcxmSnEqzImgwpoAbDTHODmNkNnMaBOk1Qk1+r8EUHAIN6nTiqTTHDvIGpgz
QhN6K43Pakh4vRI1P4rz5pVNCvdDplVPZqigVqfIbOZuX3rFFf5Fg7UIb/j/ZeRD
39xHRL+mzJE0xaJzx7tAXa6TBiWlWeuvFx/4r7bo+goQRDal375W1HZfML0BzLZ8
E3OkuWCJzd76JCWX+YiN
=DB2P
-----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>19feaf1b-9e2e-4252-a67f-e63356c08eaa</Id>
  <HashAlgorithm>SHA512</HashAlgorithm>
  <EntityType>Script</EntityType>
  <TimeStamp>2016-10-18T05:45:38.6905547Z</TimeStamp>
  <Duration>-1.00:00:00</Duration>
  <Key>0x9559f6017247e3e2</Key>
  <Signature>
    xgzHN3usO4J3t/XdGyLf73btuE987aQ5Wtds56DS0Ln6eaPbEZHogPf/IvgbsN1l+QC08iwNcnZy
    T+bcQ84mYk6VCGoGRuO0Bckwya9+NGs242CqZBudoUOe2/YAP6doJ0TkOBQgjoDAyQUNkMhSk0AQ
    ZWthOQXJNkPXwCv7Nx+ONWMDWLolN5ik4QXZIBTAHaO2UUaxt4MXa7CeEDLE49Z5a/bNDmUZyWfj
    41X+jDsmaop/tSuGmLBAVcZWJ4sAA4saHJSHGjGIVvEDyVXCLP9DT1eH/s0ds14W+Gsl6BYtEyvk
    aC+uhyqDqd7GQ6/REC8qLs/gchZ6Pi9XmQiGOzXGuY8MB3+Q3FDhu/F8r6srA2TIeZVPHs9Ra5XQ
    rcs1zD6pg5UGRDdOBzcm1iOTJkVXaZoCHlVcpx1YerBcoT7pPXgm1VHhfzOnz99np/IUHXvsi8m8
    VprOMGRL05xrVHM/7fXGOOtAfm5sqgbo/rd9I2QTDS4YWP7ilwb5TdzFtA3fJ0ew5zqVjR1F1vrW
    wWqlkGg28EU/2CXm2sDMQO1oovQ6XuHXJD5MNoePY6+txaD8ah5Y+fEIW1lRYiGtjTvmNQBpmEHf
    wZGDJtnNrJYBE3xZrPORRmKP4dsy5v7vAx8EBMb1y/RJBudKxiSsnhhrf2dkCcyg9tzYBskQgll0
    z7PXSi4MjzGE9myjjFPduQCIPUewMDulcl88NTXLmFayCrEyDB9O1/ytIimtrNupeC+FwfOwrWI3
    Wd2CjjiwoUgBDJJZJ90DXLeO4+DZQ4/4TtXqL4lLeRaAt2UPiMDnwaO8kDTb61a8RxapZf2E17/y
    q2i4Y/x5EvWHqzqiGBA+QOvn0fwi9sVeNkwn3xmui6ItQPguAlqT4+/qy1p6klJg1QWnvcuuBcYW
    MPVIDCuWVHXP0ZEocYmyFBvYwMUWDhPiDQRg3OQDxJzImwkBsvD/d7UCRqzzo82dwOXnZ9aS/4Ss
    LkoePwd/AwqELeN4isyWIKfN0Sk8e43G3BUPuhjmP7I/WDGDh+qKbGGbJnmz4xKtF/7rH6rLc5ZX
    3PR5W4kIAxlJB3uysL6TSnaMztOJ31OXoIiC2hfHIoeVBOsq1usDn9DKpCFARZ6m/B7jM6thtP2I
    qs1kGG98Q+EoYk3nrMzMyzhemndQMJrUBi5iuEu0YbbuvgTqPfglpLOVxUITketgHrrQFlTtlu8O
    zhxZdT6uKIPVDeEUr1LAcEJUqetHvqqhZfOxznQWjH0UD4KHuFcFD2ozeSt8MjtjalLc03WZzQbj
    dMTGRwPYcP39LhssB4CnoQF+gYnKHkFD6uA7Zc/RzpdzASgOXq/iAEmcpgtiIpA8f69OY3Egwi80
    j09N9ilVMHBAV6YEhXVLJXEj/d8APMY6FkLzcEnKf+f7zH/nLBoZF5b3XzDzmoMYlP0ZMQxnOHo5
    DbUW4K8YD7hV+DvceIOWEoeODZ1EBnSOrqLdWbWw83UqNlP5XIVnJFZcGtY9COSTDzrDjw5O5vCM
    o0V9gY1s4AaPXPv59xzVO99prm6ApC3nde5LHVhM3RAiHCZLK3Oo50NdrLL98ZsqCuD8XqfEnpww
    1nTMugFEIPQjHYcalW5zbB6O0b9lzbHmM4ddbzF+0fo6Ef9urZmAsfebRB+TEaDVszsQj+44pBNM
    NYOYLGdlhmZVgtUoQEvQYr1X8ER6bLLzTw5Vf7XNPlIMuI5ykzuX6znLyJh4SJlaa/UQXjIztrvJ
    aGRm1TVz+qxJ3sdw3txQVs+oRMgPBgHsjaPdeGR4+zDsMzbbl+vIcH7abVpwJaNvYXDQLFTeQeNe
    hZXKGCPESfLMhzOeXB/oiEs1UFYHilJxr69/rZQpfJ80kAyzC0VVFZysaW85O5pa8rk+eGkqJXPl
    G0Cd5KvcXgRvmNdjJC27sQ3AG0d9BaVWdd73oxhm4k03Sdbdh3OihS0QoQ7q5wZNItXuVAn4piIz
    mOFzE4DrRtnxiXqo2z6qD8jOb0atWmQKwYtCf7GqI4w1wYk5E8FI3h6/KWb6o1Lguoir0MgGl05p
    yxNTNF1b3C5EcRxpROx40mFVvNQ8zOlVuA+gLrlpneOrIsxCcGwkHeYluyXVxXkZQ5ZnOiLljihx
    2wxue0BrtBJFlJchgRe8+LqhxfbP+2Z/RZ7qUEAHuDyR9V6lLCxjMDOeiji8S5b7/+a8AZENe7LR
    JGojYmE9wc8L7W+Cq2Fc8bAP6sThdV8ihzs14WTjzp4eW4Uy66UKrnIQs47zVD7p7AUaHcwEEwDU
    39Zy1HGxnAWFJf+pFzaaBnrgo6vgMKzlQH14cPJ20/AjPYiZmqzWdZKZyafvKr73cAWm0H1l/Fif
    LvYxSkXj0QFqP9rJMnY//RyqAb+9KMCfI3MljkM+Wz2YgC2VqcQT4fjO6TLefgJfsc0Qhvg7Lqu8
    2P/YPbR5b/WwEQq+EKr7tslmXlsF997zD6pI2ixopj/L3+crzHm8xqNOEBR7vzApIq8Ya7mvS10x
    tZsQeFLV30Na8gwfOyUW2oMcempi4xnRNAy9/GvTmQRqCG0OgelPROJdSNK50mSwl72ObH7dI0Qu
    NekuOjCxaKoXMQ8BuvQ6EfF2URZq4CLPmvVf3KuGzWn2aycG1B/1FTA29/n7dYsDfeGyQ9vbO7Rc
    ZHKATjcumVBpcsnk390n3MLYPcGTfO4Olf26837Cw1M0dO2BOGLBrvakLvXrZwdd5k2F6rY=
  </Signature>
</Certificate>

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

iQIcBAABCAAGBQJYBbdpAAoJEFAslq9JXcLZm+AQALTT+dgXi4HXPZU1zs9I9zXE
+L+KL+V7OrCxXOd5XS23q7KJ2GT3omXWnn+OY4Dejer/kU67RuDgPVUmwUs/apAW
39iRzwdVWXPSeC4kd0bjPhN1W0P4ttJXJiT7NuLH6+UI1sEBIdTGCa1k6Vnf+N0b
y6xbZISKPwWUMjnuZPFs/ARpJaPtk4QeDuDwiiglQSzQBnoh/1sktpl8vhGq5C7A
ANKQoDXgSi1RvZgNw4liQ4WsKYWPsrmnSrlQxN0cEm/w6t+ghnp4a34z6bCoYtCz
K9lXDUISqRbPt2m48IUhllULk/MgGAubPR4T7yuBS/oC5nsYT3BqTZcx1/1ih5BH
bWS23u44DcHYkt011aO5t94kZBV9pSXXFKXO6/7NLbZDIt/cVN8czo2Uoe+c4yfq
+HWIql+nKzo7lTPeqaf3w1egoKANbOo+Ye/eXJjGQu99I2oGVNrLY3XF+66LIbm/
YMu1Uj3qj/1nthcQPfJZRsN/EXAGHkOgAoSfRfFaMkeL7nvD6BcFtdgU5N+uSiKM
sHDYUUKIP7ciZI2MAbVTgCB838/D20rDzbmTBs6y9iEV6guv8PctGhTe9OZFemDS
42YqwqAzlNEmZXqCp7LYulDpFdq7Iu9kbEglBzQFwcIFax1Wlu+J+k0gBC1QpTqi
cz9O31sYB9P/gh2nviKf
=UvlD
-----END PGP SIGNATURE-----